"Without data, you're just another person with an opinion." — W. Edwards Deming

---

◈ What Lives Here

This is a living repository — still being written, still growing. It's the Semester 3 archive for everything SQL: fundamentals drilled from the ground up, schema design, real database engines, case studies across SQLite and MySQL, and the beginnings of project-level work.

Unlike the previous semesters, this one isn't sealed. New queries get added. New case studies land. The certifications folder is waiting to be filled. Come back and it'll be bigger than you left it.

---

◈ Vault Structure

sql-data-intelligence/
│
├── 📘 01_SQL_Fundamentals/
│ ├── SELECT_Basics/
│ ├── Filtering_WHERE/
│ ├── Sorting_ORDER_BY/
│ ├── Arithmetic_Operations/
│ ├── String_Functions/
│ ├── Date_Functions/
| ├── Conditional_Logic/ │ ├── Aggregate_Functions/
│ ├── GROUP_BY_HAVING/
| ├── Conditional_Aggregation/
| ├── Set_Operations/
│ ├── Subqueries/
│ ├── Joins_Multiple_Tables/
│ ├── Window_Functions/
│ ├── INSERT_Data/ │ ├── UPDATE_DELETE_Data/ │ └──Transactions_Basics/ │
├── 🏗️ 02_Database_Design/
│ ├── ER_Diagrams/
│ ├── CREATE_OBJECTS/ │ └── Normalization/ │
├── ⚡ 03_Advanced_Topics/
│ ├── CTEs_Recursive_Queries/
│ ├── ALTER_DROP_Operations/
│ ├── Views/
│ ├── Triggers/
│ └── Stored_Procedures/
│
├── 🔍 04_Case_Studies/
│ ├── SQLite/
│ │ └── Intro_Challenges/
│ └── MySQL/
│ └── Practice_queries/
│
├── 🚀 05_Projects/
│ └── Imaginary_Product_Project/
│ ├── challenges_breakdown/
| ├── PROJECT_README.md # README file
| ├── quality_analysis.sql # Complete solution query
| ├── sample_data.sql # Sample data for testing
| └── schema.sql # Table creation scripts
│
├── 🐍 06_SQL_with_Python/
│ └── → Integration of SQL with Python for data extraction,
│ analysis, and workflow automation.
│
├── 🏆 07_Certifications/
| ├── sqlite_fundamentals_certificate.png
│ └── Vlw83F-sqlite-oRigJZ.pdf
│
└── README.md

---

◈ Chapter Breakdown

📘 01 — Fundamentals | The Query Foundation

Every SQL skill is built on these. This chapter is a thorough ground-up study of the language — not just syntax, but thinking relationally.

Module	What Was Covered
SELECT Basics	Projection, aliasing, selecting from tables
Filtering with WHERE	Conditions, comparison operators, BETWEEN, IN, LIKE, NULL
Sorting with ORDER BY	ASC / DESC, multi-column sorts, NULLS FIRST/LAST
Arithmetic Expressions	Column-level calculations, derived fields
String Functions	UPPER, LOWER, CONCAT, TRIM, SUBSTRING, REPLACE
Date Functions	NOW(), DATEDIFF, DATE_FORMAT, temporal arithmetic
Conditional Logic	CASE WHEN, IF, COALESCE, NULLIF — handling conditional values
Aggregate Functions	COUNT, SUM, AVG, MIN, MAX
GROUP BY & HAVING	Grouping rows, filtering aggregates, nested logic
Conditional Aggregation	SUM(CASE WHEN...), COUNT(CASE WHEN...) — pivoting and flexible aggregations
Set Operations	UNION, INTERSECT, EXCEPT — combining multiple result sets
Subqueries	Scalar, correlated, and nested subqueries
Joins	INNER, LEFT, RIGHT, FULL OUTER, multi-table joins
Window Functions	ROW_NUMBER, RANK, DENSE_RANK, LEAD, LAG, OVER()
INSERT Data	Basic INSERT syntax, multiple rows, INSERT...SELECT
UPDATE & DELETE Data	Modifying existing records, UPDATE with joins, safe deletions
Transactions Basics	BEGIN, COMMIT, ROLLBACK, ensuring data consistency

This is the longest chapter — and intentionally so. Fundamentals done properly are what every advanced query is built on. The Theory section provides optional deeper understanding for those curious about the mathematical foundations of SQL.

🏗️ 02 — Database Design | Before the First Query

Good queries start with good schemas. This chapter is about learning to design databases — understanding how data relates before a single row is inserted.

Module	What's Covered
ER Diagrams	Entity-relationship modeling, cardinality, primary & foreign keys
CREATE OBJECTS	Object creation syntax, defining structure with DDL
Normalization	1NF, 2NF, 3NF, BCNF — eliminating redundancy and anomalies

Schema design is the silent skill that determines whether a database scales gracefully or collapses under its own weight. Normalization ensures your data remains consistent and efficient.

⚡ 03 — Advanced Topics | Beyond Queries, Into Systems

This chapter brings together everything that makes SQL powerful beyond basic querying — from writing cleaner, more expressive queries to building intelligence directly into the database itself.

Module	What's Covered
CTEs & Recursive Queries	Common Table Expressions, hierarchical data traversal, self-referencing structures
ALTER & DROP Operations	Modifying schemas, adding/removing columns, managing tables
Views	Reusable query abstractions, security layers, simplifying complex joins
Triggers	Event-driven automation, maintaining data integrity, audit trails
Stored Procedures	Encapsulating business logic, parameterized operations, database-side functions

This is where SQL stops being just a query language and becomes a system design tool — combining expressive syntax with database-embedded logic.

🔍 04 — Case Studies | Real Engines, Real Problems

Two database engines. Two different contexts. Same SQL discipline applied across both.

SQLite — Intro Challenges Lightweight, file-based, and perfect for learning query logic without infrastructure overhead. These challenges focus on solving problems with clean, precise SQL.

MySQL — Practice Queries The industry-standard relational engine. Practice queries here deal with more complex schemas, multi-table logic, and the specific syntax and functions MySQL brings to the table.

🚀 05 — Projects | Putting It All Together

Imaginary Product Project — A self-contained database project simulating a product factory's quality control system. You are a procurement specialist analyzing technical specifications across four product lines to identify the highest-quality parts for purchase. The project features custom schema design, multi-table analysis with CTEs, advanced filtering logic, and cross-product quality aggregation to answer the core business question: "Which part designs consistently deliver the best performance across all product lines?"

This is where the fundamentals stop being exercises and start being applied.

🐍 06 — SQL with Python | From Queries to Workflows

SQL doesn't exist in isolation in real-world systems. This chapter introduces integration with Python for building data workflows and analytical pipelines.

Planned topics include:

• Connecting to databases using Python
• Executing SQL queries programmatically
• Fetching and processing results
• Combining SQL with data analysis libraries

This is the bridge between database querying and real-world data applications.

🏆 07 — Certifications | In Progress

Issue date: 10 May 2026
Issued by: Coddy
Credential ID: Vlw83F-sqlite-oRigJZ

What I Learned:

• ✅ Selection basics and Aggregate functions
• ✅ Advanced querying with Window Functions, CTEs, Subqueries
• ✅ Multi-table joins and complex aggregations
• ✅ Real-world project: Quality Analysis Project

📜 View Full Certificate (PDF)

---

◈ A Query Worth Showing

-- What does this repo look like, expressed in SQL?SELECT
chapter,
topic,
COUNT(*) AS files_written,
MAX(complexity_level) AS peak_difficulty,
RANK() OVER (
ORDER BYCOUNT(*) DESC
) AS depth_rank
FROM sql_data_intelligence
WHERE semester =3AND still_learning = TRUE
GROUP BY chapter, topic
ORDER BY depth_rank;

---

◈ Engines in Use

Engine	Use Case	Status
	Intro challenges, local practice	✅ Active
	Practice queries, project backend	✅ Active

---

◈ How to Explore

# Clone the repository
git clone https://github.com/MuhammadAhmadHamim/sql-data-intelligence.git
# Run any .sql file in MySQL
mysql -u root -p your_database < 04_Case_Studies/MySQL/Practice_queries/01_practiceQueries.sql
# Run any .sql file in SQLite
sqlite3 database.db < 04_Case_Studies/SQLite/Intro_Challenges/01_parliamentaryElection.sql

MySQL: v8.0+ recommended | SQLite: v3.x | GUI: DBeaver, TablePlus, or MySQL Workbench

---

◈ Skills Being Forged

---

◈ A Note on This Work

The first two semesters have archived, sealed repos. This one is different — it's still open, still being written. Every week something new gets added: a trickier query, a more complex schema, a new case study challenge.

SQL is not a language you learn once. It's a language you keep getting better at. This repository is proof of that process, in real time.

---

Queried with curiosity. Designed with intent.