PolyU | Database Principles

This lesson introduces digital data as the foundational representation of real-world information, explaining how discrete values are processed into meaningful insights. It further explores the architecture of modern software, detailing how data flows from user interactions through application logic to persistent backend storage.

This lesson explores how to bridge the gap between physical business operations and digital databases through structural abstraction and domain analysis. Students learn to translate real-world entities, attributes, and relationships into conceptual Entity-Relationship (ER) models to create organized, efficient data structures.

This lesson introduces data selection as a vital process for extracting relevant information from large datasets to prevent information overload. It further distinguishes between selection, which filters rows based on specific conditions, and projection, which isolates specific columns to refine query results.

This lesson explores how databases function as dynamic systems that transition between states through managed operations like inserts and updates. Students will learn how to maintain data integrity and consistency during these transformations to ensure that database records accurately reflect real-world events.

This lesson introduces data summarization in SQL, focusing on using aggregate functions like SUM(), AVG(), and COUNT() to transform granular row-level data into meaningful high-level metrics. Students will learn the importance of execution order, specifically how the WHERE clause filters data before aggregation, to effectively convert raw operational records into actionable insights.

This lesson explores the principles of relational database design, focusing on how separating data into distinct, linked tables eliminates redundancy and ensures data integrity. By using unique identifiers to connect related entities, students learn how to prevent maintenance anomalies and create more efficient, scalable data structures.

This lesson explores relational reasoning, the process of using primary and foreign keys to connect normalized data across multiple tables to prevent redundancy. It also examines the limitations of inner joins, highlighting how they can cause data loss by silently omitting records that lack a matching key.

This lesson introduces query composition and decomposition as essential techniques for breaking complex data retrieval tasks into smaller, manageable, and sequential logical steps. By using modular structures like sub-queries and Common Table Expressions (CTEs), developers can improve code readability, simplify debugging, and ensure greater accuracy in their database workflows.

This lesson explores the importance of relational database design and normalization in eliminating data redundancy and preventing update anomalies. Students will learn how to organize information into connected tables using primary and foreign keys to ensure long-term data integrity and system efficiency.

This lesson explores how database execution environments and vendor-specific dialects can cause syntactically correct SQL to fail or behave inconsistently when migrated between different systems. It also introduces transaction management as a critical mechanism for bundling operations into indivisible units of work to ensure data integrity and consistency.

This lesson emphasizes that database developers must look beyond logical correctness to ensure queries are optimized for performance and scalability. By understanding the query execution pipeline—from parsing to physical planning—developers can avoid resource-heavy operations like full table scans and utilize efficient indexing strategies.

This lesson explores how AI-driven natural language processing enables non-technical users to query databases by translating conversational requests into structured SQL. It emphasizes the importance of implementing security guardrails and verification steps to mitigate the operational risks associated with automated database interactions.

This lesson explores the architectural limitations of relational databases, highlighting how their rigid, table-based structures can struggle with the diverse and rapidly evolving data demands of modern applications. Students will learn to identify when these constraints create performance bottlenecks and how to evaluate alternative storage models to better support complex, non-relational workloads.