Amr Abdelkarem’s Post

SQL Looked Easy at First. Then Came Joins. The class that almost broke me and the lesson that came out of it. I will be honest with you. There was a moment in my last class where I genuinely considered whether this was for me. SQL started simple enough. Selecting columns, pulling records - manageable. Then the complexity arrived, fast and unannounced. SELECT, FROM - "This is fine." Extracting columns and records. Straightforward. I was feeling confident. WHERE, ORDER BY, GROUP BY, HAVING - "Okay, I am still here." Filtering and sorting data. It was getting tougher but I was keeping up. JOINS and Subqueries - "Wait. What?" Combining tables. Nesting queries inside queries. My brain had to work in ways it had never worked before. "Imagine writing a full query, staring at the screen and being too scared to hit Run."😅 That was me. More than once. And somehow that made me laugh and push through. 💡 What SQL Taught Me The biggest shift was learning to slow down before I type a single line. Understanding what the result should look like before writing the query is everything. Because in SQL, you can run a query, get a result that looks perfectly fine and still be completely wrong. That is the part nobody warns you about. Break the question down. Picture the output. Then query. Stressful? Absolutely. Worth it? Without a doubt. Every tool in this training has pushed me past a wall I did not know I had. SQL just happened to build the tallest one yet. Still standing. Still going. 🚀 Where did SQL start to click for you? You can share below Pushed through with the guidance of Obumneme Udeinya #SQL #DataAnalysis #LearningInPublic #SQLJoins #DataAnalyst #LearningInPublic #GrowthMindset #BeginnersJourney #LMTechHub #Cohort6

🗄️ SQL Roadmap (Beginner → Advanced) If you're learning SQL and not sure where to begin — here’s a clean and focused roadmap to master it step by step 👇 🟢 1. Basics (Foundation) ✔️ Database & RDBMS concepts ✔️ Tables, Rows, Columns ✔️ SELECT, FROM ✔️ WHERE ✔️ ORDER BY, LIMIT 🔵 2. Intermediate SQL ✔️ JOIN (INNER, LEFT, RIGHT) 🔥 ✔️ GROUP BY ✔️ HAVING ✔️ Aggregate Functions (COUNT, SUM, AVG) 🟡 3. Advanced SQL ✔️ Subqueries ✔️ Window Functions (ROW_NUMBER, RANK) ✔️ CASE WHEN ✔️ CTE (Common Table Expressions) 🟠 4. Data Manipulation ✔️ INSERT ✔️ UPDATE ✔️ DELETE ✔️ TRUNCATE ✔️ Transactions (COMMIT, ROLLBACK) 🔴 5. Database Design ✔️ Normalization (1NF, 2NF, 3NF) ✔️ Primary Key & Foreign Key ✔️ Relationships (1-1, 1-M, M-M) ✔️ ER Diagrams 🟣 6. Performance Optimization ✔️ Indexing 🔥 ✔️ Query Optimization ✔️ Execution Plans ⚫ 7. Practice & Problem Solving ✔️ Solve SQL queries regularly ✔️ Work on real datasets ✔️ Focus on logic building 🎯 Simple Flow: Basics → Joins → Advanced → DML → Design → Optimization → Practice 💡 Tip: Mastering SQL is about writing better queries, not just more queries. Consistency is key 🔑 #SQL #Database #DataAnalytics #Programming #Learning #CareerGrowth

My SQL learning Journal Day 32: SQLComments 📝 Today, I explored the SQL comments, and it's the smallest SQL feature with the biggest impact on teamwork. What is a SQL comment? Comments are used to explain SQL code or to temporarily prevent execution of SQL code (for debugging). Comments are ignored by the database engine. It simply means: Text in your code that the database ignores. It is just for you and anyone else reading your query. Two types I learned today: 1. Single-line comment: Single-line comments start with -- and continue to the end of the line. Any text after -- and to the end of the line will be ignored. sql syntax -- This query finds active customers SELECT * FROM customers WHERE status = 'active'; 2. Multi-line comment Multi-line comments start with /* and end with */. Any text between /* and */ will be ignored. sql syntax /*  This query calculates monthly sales. Last updated: Day 32. */ SELECT SUM(amount) FROM sales WHERE month = 'APR'; Why this is important: Code runs for machines. Comments explain for humans. Note: Comments are not supported in Microsoft Access databases. #SQL #Data Analytics#Women in Tech #LearningInPublic #BeginnerSQL

🚀 SQL Roadmap: From Beginner to Advanced 📊 Want to master SQL step-by-step? Here’s a clean, structured roadmap to guide your journey 👇 🔰 1. Basics 📌 Understand what SQL is 📌 Learn Databases & Tables 📌 Master CRUD operations (Create, Read, Update, Delete) 📌 Get familiar with DDL & DML 📊 2. Queries ✨ SELECT, WHERE (AND/OR/NOT) ✨ ORDER BY, GROUP BY ✨ LIMIT & DISTINCT ⚙️ 3. Functions 🔢 Aggregate: COUNT, SUM, AVG, MIN, MAX 🔤 String: UPPER, LOWER, CONCAT 📅 Date: NOW, DATE, DATEDIFF 🧩 NULL handling with COALESCE 🔄 4. Joins 🔗 INNER JOIN 🔗 LEFT & RIGHT JOIN 🔗 FULL JOIN 🔗 SELF & CROSS JOIN 🧠 5. Subqueries 📍 Subqueries in SELECT, FROM, WHERE 📍 Correlated subqueries 🚀 6. Constraints 🔒 PRIMARY KEY, FOREIGN KEY 🔒 UNIQUE, NOT NULL 🔒 CHECK & DEFAULT ⚡ 7. Indexes & Views 📈 Indexing for performance ⚖️ Index trade-offs 👁️ Creating & using views 🔁 8. Normalization 📚 1NF, 2NF, 3NF 📉 Reduce redundancy ⚖️ When to denormalize 🔐 9. Transactions 💾 BEGIN, COMMIT, ROLLBACK 🛡️ ACID properties ⚙️ Isolation levels 🔥 10. Advanced SQL 💡 Window Functions 💡 Common Table Expressions (CTEs) 💡 Stored Procedures & Triggers 🎯 11. Practice & Next Steps 🛠️ Build real-world projects 🎤 Prepare for interviews ⚡ Practice query optimization 💬 Consistency + Practice = SQL Mastery! #SQL #DataAnalytics #DataScience #Learning #TechSkills #Programming #DataEngineering #Database #LearningPath

🚀 My SQL Learning Journey: From Basics to Advanced I’ve been building my SQL skills step by step, focusing on creating a strong and practical foundation in data handling and analysis 📊 🔹 1. Fundamentals (Getting Started) ✔️ Learned different Data Types and how data is stored ✔️ Understood SQL operations: DDL, DML, DCL ✔️ Practiced creating, updating, and managing tables 🔹 2. Core Querying Skills ✔️ Worked with essential clauses: SELECT, WHERE, GROUP BY, HAVING, ORDER BY ✔️ Used Aggregate Functions (SUM, COUNT, AVG, etc.) to analyze data ✔️ Built queries to filter, sort, and summarize datasets 🔹 3. Intermediate Concepts ✔️ Explored different types of JOINs (INNER, LEFT, RIGHT, FULL) 🔗 ✔️ Combined multiple tables to solve real-world data problems ✔️ Improved query writing with better logic and readability 🔹 4. Advanced SQL ✔️ Learned Window Functions for advanced analytics 📈 ✔️ Used CTE (Common Table Expressions) for cleaner and modular queries ✔️ Applied CTAS (Create Table As Select) for data transformation ✔️ Worked with Temporary Tables and Views for better data management 🔹 5. Database Design & Optimization ✔️ Understood ER Diagrams & ER Modeling 🧩 ✔️ Learned Stored Procedures for reusable logic ✔️ Focused on writing efficient and structured queries 💡 This is the learning path to build a strong SQL foundation—from basics to advanced concepts—focused on real-world problem solving. 🫡Thanks Darshil Parmar for this course which helped me to clear SQL concept.🎯 #SQL #DataEngineering #LearningJourney #Database #Analytics #CoreConcept #Datavidhya

Most people learn SQL. Fewer people learn to think in SQL. There's a difference. Learning SQL means you can write a JOIN or a GROUP BY when you see the problem coming. Thinking in SQL means you look at a messy business question and your brain automatically breaks it into layers like what's the grain of this data, where does it need to be aggregated, what's the most efficient path to get there. That shift didn't happen for me in a classroom. It happened when I was building ETL pipelines and a query that looked perfectly fine was silently returning duplicate rows because I hadn't accounted for a many-to-many join upstream. A few things that actually moved the needle: → Writing CTEs instead of subqueries that forces you to name each logic step, which forces you to understand it. → Thinking about indexes before writing joins on large tables. → Reading query execution plans, not just query results. The last one is underrated. The result can look correct and the query can still be costing you 10x more than it should. SQL is one of those skills where the gap between "I know it" and "I actually know it" is wider than most people admit. What's the SQL concept that took you the longest to really click? #SQL #DataAnalytics #DataEngineering

🚀 Day 31 & 32 – SQL Journey: From CTEs to Recursive Queries Over the last two days, I explored how to make SQL queries more structured, readable, and powerful using CTEs and Recursive CTEs. 🔹 What I Learned: 📌 CTEs (Common Table Expressions) • Temporary result sets created using the "WITH" clause • Help break complex queries into simple, step-by-step logic • Improve readability and make queries easier to debug • Replace deeply nested subqueries 📌 Recursive CTEs & Hierarchical Queries • Built using Anchor + Recursive part • Execute repeatedly until a condition is met • Useful for working with structured data like trees and sequences 📌 Hierarchy Concepts Practiced: • START WITH • CONNECT BY PRIOR • LEVEL • SYS_CONNECT_BY_PATH • CONNECT_BY_ROOT 🔹 Hands-on Practice: ✔️ Calculated aggregated results step-by-step using CTEs ✔️ Generated numbers from 1 to N using recursion ✔️ Identified missing values in sequences 🔹 What Changed: Earlier → Writing queries Now → Structuring logic + understanding execution flow step-by-step 💡 Key Insight: CTEs make SQL clean and modular, while recursive queries unlock the ability to work with hierarchical data and patterns — something very common in real-world scenarios. 🔥 Takeaway: Better structure → Better readability → Better problem solving 📈 Learning step by step 🚀 #SQL #CTE #RecursiveCTE #DataAnalytics #LearnSQL #SQLJourney

𝗚𝗼𝗼𝗱 𝗦𝗤𝗟 𝘄𝗼𝗿𝗸𝘀. 𝗖𝗹𝗲𝗮𝗻 𝗦𝗤𝗟 𝗶𝘀 𝗲𝗮𝘀𝘆 𝘁𝗼 𝗿𝗲𝗮𝗱, 𝗱𝗲𝗯𝘂𝗴, 𝗮𝗻𝗱 𝘀𝗰𝗮𝗹𝗲. When you start learning SQL, the main focus is usually getting the correct result. But in real-world projects, writing clean and readable SQL is just as important. Because your queries will be read by: • teammates • analysts • engineers • your future self Here are 4 simple practices that instantly improve your SQL quality 👇 1️⃣ Use aliases for readability Aliases make queries shorter and easier to understand. Instead of repeating long table names, use meaningful aliases. Example: SELECT u.id, u.name, SUM(o.amount) AS total_spent FROM users AS u JOIN orders AS o ON u.id = o.user_id GROUP BY u.id, u.name; 2️⃣ Format queries properly Well-formatted SQL is much easier to debug and maintain. Best practices: • Use uppercase for SQL keywords • Place each clause on a new line • Align JOIN conditions 3️⃣ Follow naming conventions Consistent naming makes databases easier to navigate. Common convention: • snake_case for tables and columns • descriptive column names Example: customer_id order_date total_amount 4️⃣ Avoid SELECT * It might feel convenient, but it can: • slow down queries • retrieve unnecessary data • break code when schema changes Better approach: SELECT order_id, order_date, total_amount FROM orders; 💡 Key takeaway Clean SQL isn't just about style — It makes your queries faster to understand, easier to maintain, and more production-ready. Small habits like these make a big difference in real data projects. Curious to know 👇 What’s one SQL habit that improved your queries the most? #SQL #DataAnalytics #LearningInPublic #SQLTips #DataAnalyticsJourney

How much SQL is required for product bases roles ? Most people spend 6 months “learning SQL”… …and still can’t solve real-world problems. Why? Because they never practice the right way. Here’s the shortcut Master these 8 GitHub repos… and you’ll be ahead of 90% of SQL learners. Here are 8 GitHub repos that will take your SQL skills to BOSS-level: 1. Basics | Learn-SQL https://lnkd.in/gR4VfqHF 2. Netflix-Shows and Movies SQL https://lnkd.in/gNBdAgBb 3. SQL in 30 Days https://lnkd.in/gpY_Yevk 4. SQL Masterclass https://lnkd.in/gBVGkfv8 5. SQL Music Store Analysis https://lnkd.in/g3Uzc4Hr 6. SQL Hands-on https://lnkd.in/g3uHJhBk 7. SQL Murder Mystery https://lnkd.in/gVTGwnqe 8. Beyond LeetCode SQL https://lnkd.in/g92JKggB Each repo covers a different use case: - From basics to advanced - Real business scenarios - Hands-on practice SQL is the one skill that can unlock your path into Automation, Analytics, and high-impact roles.

How do you get good at complex data manipulation in SQL? Imagine being able to make informed business decisions. And write easy-to-understand SQL. That is what SQL proficiency is. The expectation from an advanced SQL practitioner is not just the ability to answer complex questions. But the ability to answer complex questions with easy-to-understand SQL. 1. Master the "Logical Order of Execution" 🧠 SQL doesn't run in the order it’s written. The SELECT statement is actually one of the last things the engine processes. The flow: FROM → JOIN → WHERE → GROUP BY → HAVING → SELECT → ORDER BY. Why it matters: Once you realize the WHERE clause happens before your aliases are created, your "Column not found" errors disappear. 2. Think in "Windows," Not Just "Groups" 🪟 GROUP BY is a sledgehammer; it collapses everything. Window Functions (OVER, PARTITION BY) are a scalpel. Want a running total? Use a Window. Need to find the "Top 3 sales per region"? Use DENSE_RANK(). Comparing this month to last month? LAG() is your best friend. 3. Modularize with CTEs (Common Table Expressions) 🧱 If your query looks like a 200-line "spaghetti code" nest of subqueries, it will break. Use WITH statements to break your logic into steps. Step A: Clean the data. Step B: Join the sets. Step C: Final aggregation. Your future self (and your teammates) will thank you for the readability. 4. Solve the "Hard" Problems 🧩 You don't get better by doing simple Joins. You get better by tackling: Gaps and Islands: Finding sequences of consecutive data. Pivoting: Turning "Long" data into "Wide" reports manually. Self-Joins: Managing hierarchical data (like Org Charts). Complex SQL isn't about knowing more commands; it’s about knowing how to structure your logic before you even touch the keyboard. #SQL #DataEngineering #DataAnalytics #BusinessIntelligence #DataScience #CodingTips