ISYS1055 Database Concepts
The Complete Study & Assessment Guide · S2 2026Database Concepts
ISYS1055 Database Concepts is RMIT University's introduction to relational database design and SQL, taught out of the School of Computing Technologies and delivered through Canvas with a weekly lectorial (RMIT's combined lecture and tutorial class) and a weekly practical. The five Course Learning Outcomes (CLOs) published on the Canvas welcome page run from describing the theoretical basis of the relational model to developing a sound design and applying SQL to define schemas, update contents and extract data. The course runs in one straight line: relational foundations and integrity constraints (Weeks 1-2), entity-relationship modelling in UML notation and the seven-step mapping to a relational schema (Weeks 3-4), SQL on SQLite through SQLite Studio (Weeks 5-8, including joins, nested queries, grouped aggregation, views and triggers), relational design and normalisation to 3NF (Weeks 9-10), and document modelling with MongoDB on Atlas (Week 11), before a revision week that presents no new material. There is no exam in this course. The whole 100% sits in four continuous tasks: Assessment Task 1 Database Design 20%, Assessment Task 2 SQL Programming and Normalisation 30%, Assessment Task 3 in-class quizzes 20% (five online quizzes run inside your practical class in Weeks 3, 5, 7, 9 and 11, stated as 5 x 4 = 20 marks, 4% per quiz), and Assessment Task 4 Database Design Project 30%. Canvas sometimes calls Assessment Task 4 the "Final Assessment", but the link behind that phrase is the Database Design Project - a take-home build on a publicly available dataset, not a written paper. Three of the four tasks open with a draft gate roughly two weeks before the final submission, and each gate carries its own penalty wording in the course source, so the cheapest marks in the course are the ones you lose by not submitting a draft. Hurdle requirements: none stated in the course source. The course is co-taught in the same Canvas shell as the postgraduate ISYS3412, and two of the rubrics print two mark columns - always read the ISYS1055 column. The toolchain is SQLite Studio for SQL, LucidChart for UML entity-relationship diagrams (free with an RMIT academic account) and MongoDB Atlas plus Compass in Week 11. SQL scope is stated as SQL-92 standard features except for the handling of dates and times, with all activity carried out on SQLite. The result you take out of this course feeds the Grade Point Average (GPA) RMIT reports. Weights, due windows and submission rules here mirror the Canvas Syllabus for the Semester 2, 2026 offering - confirm the current version on Canvas and in the Course Guide (Part A and Part B).
What ISYS1055 covers
ISYS1055 runs as twelve teaching weeks in one straight line: relational foundations (Weeks 1-2), entity-relationship modelling and schema mapping (Weeks 3-4), SQL on SQLite (Weeks 5-8), relational design and normalisation (Weeks 9-10) and NoSQL with MongoDB (Week 11), before a revision week with no new material. The assessment tracks that arc exactly - Assignment 1 lands after the ER weeks, Assignment 2 after normalisation, the five quizzes fall in the practicals of Weeks 3, 5, 7, 9 and 11, and the Database Design Project closes the course in Week 14. The chapters below follow the same teaching order, so you can read forward with the course or jump straight to the week you are being assessed on.
How ISYS1055 is assessed
| Component | Weight | Format |
|---|---|---|
| Assessment Task 1 - Database Design (take-home assignment on ER modelling and the relational database model) | 20% | Take-home. Two parts / four tasks covering Basic ER Modelling and Basic Relational Modelling. Rubric points: Task 1 Design ER Model 4, Task 2 ER to Schema 4, Task 3 Optimise ER Model 6, Q4.1-Q4.4 Understanding the Model 1 each, Q4.5 SQL Statement Validity 1, Q4.6 SQL Statement 1 (20 points, scaled to 20%). Draft due end of Week 4; final due end of Week 6 (the Semester 2, 2026 due windows - confirm the dates on Canvas). |
| Assessment Task 2 - SQL Programming and Normalisation (take-home) | 30% | Take-home. Part A normalisation: Q1 Listing Functional Dependencies, Q2 Identifying Highest Normal Form, Q3 Decomposing Relations up to 3NF, Q4 Cleaning up the schema by combining relations, Q5 Final Relational Schema. Part B: five SQL queries. Use the 'Marks (ISYS1055)' rubric column (3 / 4 / 3 / 1.5 / 0.5 and 0.5 / 0.5 / 1.5 / 1 / 1.5), not the ISYS3412 column; the page states the score is scaled to 30% of the overall course assessment score. Draft due end of Week 9; final due end of Week 11 (the Semester 2, 2026 due windows - confirm the dates on Canvas). |
| Assessment Task 3 - In class quizzes | 20% (stated as '5 x 4 = 20 marks' and '4% per quiz') | Five online quizzes run inside the PRACTICAL classes in Weeks 3, 5, 7, 9 and 11. Official description: 'a mixture of multiple choice and short answer questions', covering topics from previous weeks and assessing relational database fundamentals, entity-relationship modelling and SQL programming applied to real-world applications. |
| Assessment Task 4 - Database Design Project (Canvas also calls this the 'Final Assessment'; it is a take-home project, NOT an exam) | 30% | Take-home project on a publicly available dataset: investigate and understand the data, design a conceptual model, build the database and host the data, then write SQL for a set of requirements. Part A Understanding the Data 0 marks (preliminary work), Part B Designing the Database 10, Part C Creating the Database 10, Part D Data Retrieval 10. Milestone 1 is to be started over the semester break; the syllabus lists a live walkthrough for starting it in Week 8, without naming the class it runs in. Draft due end of Week 12; final due end of Week 14 (the Semester 2, 2026 due windows - confirm the dates on Canvas). |
AT2 Part A shape: list the FDs, derive the primary key, name the highest normal form, decompose to 3NF
- +1Read the FDs off the business rules, not off any sample rows. F1: orderNo → orderDate, customerEmail. F2: itemCode → itemName, bakerCode. F3: bakerCode → bakerName. F4: orderNo, itemCode → quantity. Do not list orderNo, itemCode → itemName separately: it is derivable through F2, and derivable FDs are struck out.
- +1Derive the key by right-hand-side elimination. Strike out every attribute that appears on the right of any FD: orderDate, customerEmail, itemName, bakerCode, bakerName, quantity. What survives is orderNo and itemCode, so PK = {orderNo, itemCode} - a composite key. Do not trust a key you were handed and do not substitute common sense for the procedure.
- +1Highest normal form. Every component holds one atomic value and there is no repeating group, so the relation is in 1NF. It is not in 2NF: the key is composite and F1 shows orderDate and customerEmail depend on orderNo alone - part of the key - which is a partial dependency. Highest normal form = 1NF.
- +11NF → 2NF. Remove each partially dependent group together with a copy of its determinant; the determinant becomes the primary key of the new relation and stays behind in the original as a foreign key. This gives OrderLine(orderNo*, itemCode*, quantity), Orders(orderNo, orderDate, customerEmail) and Item(itemCode, itemName, bakerCode, bakerName) - bakerName travels with itemCode too, because itemCode → bakerCode → bakerName makes it dependent on that part of the key.
- +12NF → 3NF and final schema. In Item, bakerCode → bakerName is a non-key attribute determined by another non-key attribute - a transitive dependency - so split it out the same way. Final 3NF schema: OrderLine(orderNo*, itemCode*, quantity) · Orders(orderNo, orderDate, customerEmail) · Item(itemCode, itemName, bakerCode*) · Baker(bakerCode, bakerName). No two relations share a primary key, so there is nothing to merge at the clean-up step, and every relation now has a meaningful name.
Key terms
- Relation (vs table)
- A table that also satisfies all five relational rules: every cell holds a single atomic value, each column draws on one domain, column names are unique, row and column order carry no meaning, and no two rows are identical. The course states it as "every relation is a table; every table cannot be a relation". Formally, a relation schema is the name plus the attribute set, e.g. Member(memberID, email, joinDate); the instance is the data held at one point in time.
- Primary key, candidate key and foreign key
- A candidate key is a minimal set of attributes whose values are unique for every tuple; the one chosen to identify tuples is the primary key (unique, never null), the others are alternate keys. A foreign key is an attribute in one relation whose values must match a primary-key value in the referenced relation, or be wholly null. Key claims rest on the semantics of the data, not on the sample rows: email is unique by definition, a person's name is not.
- Entity and referential integrity
- The two integrity constraints the relational model enforces alongside the key constraint. Entity integrity: no primary-key attribute may hold a null. Referential integrity: every foreign-key value must already exist in the referenced primary key, or be null - so no child row is left dangling and no parent may be deleted out from under one. In SQLite the referential constraint only fires once PRAGMA foreign_keys = ON is set on the connection.
- Multiplicity (min .. max)
- The UML notation this course marks against. Multiplicity written at an association end counts how many occurrences of that entity relate to one occurrence of the entity at the other end, as a min .. max pair (1 .. 1, 0 .. 1, 0 .. *, 1 .. N). The maximums give the cardinality (1:1, 1:N, M:N); the minimums give the participation - minimum 1 means mandatory (total) participation, minimum 0 means optional (partial). Both halves come from business rules, never from sample data.
- Functional dependency
- A one-way constraint between attributes of a relation, written A → B and read as "B is functionally dependent on A" or "A determines B": each value of A is associated with exactly one value of B. A is the determinant, B the dependent. FDs come from the semantics and must hold for all time. A dependency is full when every left-hand attribute is needed, partial when a proper subset of the left already determines the right, and transitive when A → B and B → C. Normalisation is guided entirely by the FD set.
- Third normal form (3NF)
- A relation is in 3NF when it is in 2NF and no non-key attribute is determined by another non-key attribute. Read the ladder as "the key, the whole key, and nothing but the key": 1NF removes repeating groups and non-atomic values, 2NF removes partial dependencies on part of a composite key (automatic when the key is a single attribute), 3NF removes transitive dependencies. The decomposition recipe is the same each time - move the offending attributes out with a copy of their determinant, make the determinant the new relation's primary key, and leave it behind as a foreign key. This course stops at 3NF; BCNF, 4NF and 5NF are named but out of scope.
ISYS1055 FAQ
Is ISYS1055 hard?
It is a first database course, so the ideas are approachable, but the marks sit in precision rather than in volume. The three places students actually lose marks are the seven-step ER-to-relational mapping (the brief wants the partially built schema shown at the end of every step, not just the final answer), the normalisation questions (naming the highest normal form a relation is actually in, with the dependency that breaks the next one), and SQL that runs but answers a slightly different question. Nothing in this course is mathematically heavy - there are no derivations and no formula sheet - but it is cumulative: the ER modelling of Weeks 3-4 becomes the schema you write SQL against in Weeks 5-8 and the schema you normalise in Weeks 9-10. The workload guidance on the Canvas welcome page is about ten hours a week, split across preparation, the lectorial and practical, review, and assessment work. Students who install SQLite Studio in Week 1 and actually run every query they write tend to find it very manageable, and steady work protects the GPA this result feeds into.
Can AI help me with ISYS1055?
Yes, as a step-by-step study aid. Sia is an AI tutor built to mirror how ISYS1055 is taught and assessed at RMIT University: it can walk you through a UML entity-relationship model one business rule at a time, take a model through the seven mapping steps in order, explain why a query returns the wrong rows, or work an FD list down to a primary key and a 3NF decomposition line by line, checking your reasoning as you go. Bring your own practice relation or query and ask it to explain each step. It does not complete graded assessment for you, and RMIT University academic-integrity rules apply to everything you submit - use it to understand the method, and confirm what is permitted on Canvas and in the Course Guide.
How is ISYS1055 assessed?
Entirely by continuous assessment, and the four tasks sum to exactly 100%. Assessment Task 1 Database Design is a 20% take-home covering ER modelling and the relational model, with the rubric splitting into Design ER Model 4, ER to Schema 4, Optimise ER Model 6 and six 1-mark items on understanding the model and SQL. Assessment Task 2 SQL Programming and Normalisation is 30%, with Part A five normalisation questions and Part B five SQL queries - read the marks from the ISYS1055 column, not the ISYS3412 one, and note the page's own statement that the raw score is scaled to 30% of the overall course assessment score. Assessment Task 3 is five online quizzes run inside your practical class in Weeks 3, 5, 7, 9 and 11, described as a mixture of multiple choice and short answer, stated as 5 x 4 = 20 marks or 4% per quiz. Assessment Task 4 is the 30% Database Design Project, split Part A Understanding the Data 0 marks, Part B Designing 10, Part C Creating 10, Part D Data Retrieval 10. Confirm every weight and due window on Canvas and in the Course Guide (Part A and Part B) for your own offering.
Does ISYS1055 have a hurdle, and what happens if I skip a draft?
Hurdle requirements: none stated in the course source - there is no must-pass component described anywhere in the course material, so do not assume one and do not assume its absence either; the Course Guide (Part A and Part B) linked from Canvas is the definitive statement. The one penalty mechanic this course does state is the draft gate on three of the four tasks, and the wording differs per task, so read each one as published: for Assessment Task 1 the source says "up to 2 mark deduction if missing or incomplete", and elsewhere that failing to submit a draft results in a 2 mark deduction (2/20 marks); for Assessment Task 2 it says "up to 2% (mark) deduction if missing or incomplete"; for Assessment Task 4 the draft is worth "2 marks depending on how complete/correct". Each draft falls roughly two weeks before its final - end of Week 4, end of Week 9 and end of Week 12 - so it is a free feedback checkpoint with a penalty attached, and submitting something complete-looking always beats submitting nothing. Announcements on Canvas can change an assessment specification, so monitor them, and if something goes wrong use RMIT's special consideration process rather than a late private email.
Is there an exam in ISYS1055?
No. Assessment is 100% continuous - a 20% design assignment, a 30% SQL and normalisation assignment, five in-practical quizzes worth 20% in total and a 30% design project. The confusing part is that Canvas labels Assessment Task 4 the "Final Assessment", and Week 8's syllabus topic row lists a guide to starting it, but the link behind that phrase resolves to the Database Design Project: a take-home build on a publicly available dataset where you profile the data, design the conceptual model, create the database and write the retrieval queries. So there is no written paper to sit and no timetabled paper to plan around - what you plan around instead is the draft gate at the end of Week 12 and the final submission at the end of Week 14. Confirm the current assessment structure on Canvas for your offering.
How to prepare for the assessments
Treat this course as one continuous build rather than eleven separate topics, because the assessment is continuous too. Set the weekly rhythm the course itself assumes - work through the pre-lecture material and the set reading before the lectorial, take the lectorial and the practical, then revise and revisit the points you could not follow - and protect the practical, because that is where the five quizzes are run. Install SQLite Studio in Week 1 and open a LucidChart academic account before Week 3; from Week 5 on, never read a query without running it, and never submit one you have not executed against the supplied database. Map your calendar around the two mechanics that actually move marks. First, the quizzes: they fall in the practicals of Weeks 3, 5, 7, 9 and 11, they are worth 4% each, and the course states that the first four cover the previous two weeks while the last covers the previous ten - so quiz 5 is cumulative and is the one to revise broadly for. Second, the draft gates: Assessment Task 1's draft at the end of Week 4, Assessment Task 2's at the end of Week 9 and Assessment Task 4's at the end of Week 12, each roughly two weeks ahead of its final, each carrying its own stated deduction for a missing or incomplete submission. Use the semester break after Week 7 the way the Canvas Syllabus tells you to: review Weeks 1-7 and start Milestone 1 of the Database Design Project, so Part A is under way before the Week 8 walkthrough. For the skills themselves, drill three procedures until they are automatic rather than re-reading slides. (1) The seven-step ER-to-relational mapping, in order, writing out the partially built schema after every step, because the brief awards nothing to a final schema with no working. (2) Right-hand-side elimination to find a primary key from a functional-dependency set, then the 1NF / 2NF / 3NF verdict with the specific dependency that breaks the next form. (3) The SQL escalation - single-table conditions, then joins, then a nested query, then grouped aggregation with HAVING - written in the format the course requires, keywords capitalised and one clause per line. Keep everything in the SQL-92-on-SQLite scope the course states, with date and time handling as the one exception it names. When a step will not click, ask Sia to explain that single step a different way and set you a fresh practice relation or query in the same style; it teaches the method and checks your working, and it never stands in for your own graded submission. Confirm all weights, submission rules, the census date and the special consideration process on Canvas and in the Course Guide (Part A and Part B).
Your AI Information Technology tutor for ISYS1055
Stuck on a hard ISYS1055 question? Sia is AskSia’s AI Information Technology tutor — ask any ISYS1055 Database Concepts question and get a clear, step-by-step explanation grounded in how the course is actually taught and assessed. Read this whole study guide free, then take your hardest questions to Sia.
