SQL Optimization Techniques

Here are some proven SQL Optimization strategies every engineer should know ⬇️ 1. Select Only What You Need ❌ SELECT * → Loads unnecessary data, increases I/O. ✅ Select only required columns to minimize processing. 2. Use Proper Indexing ↳ Index frequently filtered columns (WHERE, JOIN, GROUP BY). ↳ Avoid over-indexing (it slows down INSERT/UPDATE). ↳ Leverage covering indexes for heavy queries. 3. Optimize Joins ↳ Ensure JOIN keys are indexed. ↳ Prefer INNER JOINs when possible over OUTER JOINs. ↳ Push filters down before joins to reduce data scanned. 4. Reduce Data Scans ↳ Use PARTITIONING on large tables (date, region, etc.). ↳ Use CBO (Cost-Based Optimizer) hints when available. ↳ Apply filter conditions early. 5. Avoid Complex Subqueries ↳ Replace correlated subqueries with JOINs or CTEs. ↳ Use window functions efficiently instead of multiple nested queries. 6. Monitor & Tune ↳ Always check execution plans. ↳ Look for table scans, sort operations, and large shuffles. ↳ Track query runtime and cost metrics, especially in cloud warehouses like Snowflake, BigQuery, Synapse. ✅ Impact of Optimization: I’ve seen query runtimes drop from 45 minutes to 2 minutes just by applying indexing and partition pruning. That’s not just performance — it’s cost savings, better SLAs, and happier stakeholders.

6 SQL optimizations that actually work (I tested all 20 popular ones) I spent a week benchmarking every SQL "optimization tip" I could find. Most made zero difference. Some made things worse. 𝐇𝐞𝐫𝐞'𝐬 𝐰𝐡𝐚𝐭 𝐚𝐜𝐭𝐮𝐚𝐥𝐥𝐲 𝐦𝐨𝐯𝐞𝐬 𝐭𝐡𝐞 𝐧𝐞𝐞𝐝𝐥𝐞: 𝟏. 𝐈𝐧𝐝𝐞𝐱𝐞𝐬 𝐚𝐫𝐞 𝐲𝐨𝐮𝐫 𝐛𝐞𝐬𝐭 𝐟𝐫𝐢𝐞𝐧𝐝 (𝐮𝐧𝐭𝐢𝐥 𝐭𝐡𝐞𝐲'𝐫𝐞 𝐧𝐨𝐭) • Index columns in WHERE, JOIN, and ORDER BY clauses • But too many indexes slow down INSERT/UPDATE operations • Monitor which indexes actually get used 𝟐. 𝐒𝐄𝐋𝐄𝐂𝐓 * 𝐢𝐬 𝐥𝐚𝐳𝐲 𝐚𝐧𝐝 𝐞𝐱𝐩𝐞𝐧𝐬𝐢𝐯𝐞 • Pulls unnecessary data across the network • Can't use covering indexes effectively • Name your columns – your database will thank you 𝟑. 𝐅𝐢𝐥𝐭𝐞𝐫 𝐞𝐚𝐫𝐥𝐲, 𝐟𝐢𝐥𝐭𝐞𝐫 𝐨𝐟𝐭𝐞𝐧 • Push WHERE conditions as close to the data source as possible • Filter before JOINs when you can • Smaller datasets = faster everything 𝟒. 𝐔𝐍𝐈𝐎𝐍 𝐀𝐋𝐋 𝐯𝐬 𝐔𝐍𝐈𝐎𝐍 • UNION removes duplicates (expensive!) • UNION ALL keeps everything (fast!) • Only use UNION when you actually need deduplication 𝟓. 𝐄𝐗𝐈𝐒𝐓𝐒 𝐯𝐬 𝐈𝐍 • EXISTS stops at the first match • IN processes the entire subquery • For large datasets, EXISTS usually wins 𝟔. 𝐃𝐈𝐒𝐓𝐈𝐍𝐂𝐓 𝐢𝐬𝐧'𝐭 𝐚𝐥𝐰𝐚𝐲𝐬 𝐲𝐨𝐮𝐫 𝐟𝐫𝐢𝐞𝐧𝐝 • Often a band-aid for bad JOINs • Fix the root cause instead • GROUP BY might be more efficient 𝐁𝐮𝐭 𝐡𝐞𝐫𝐞'𝐬 𝐭𝐡𝐞 𝐤𝐢𝐜𝐤𝐞𝐫... What speeds up one query might slow down another. Your data distribution, table size, and database engine all matter. 𝐌𝐲 𝐫𝐮𝐥𝐞? Test everything. Use EXPLAIN PLAN. Watch those execution times. Keep what works, toss what doesn't. The best optimization is the one that actually makes YOUR queries faster, not the one that got 1000 likes on LinkedIn. What SQL optimization surprised you the most when you actually tested it? 𝐏.𝐒. I share job search tips and insights on data analytics & data science in my free newsletter. Join 16,000+ readers here → https://lnkd.in/dUfe4Ac6

17 lessons I learned about Query Optimization over the last 8 years and 9 months at Amazon...(It took me a lot of slow queries to realize these, but you don't have to!) 1. Never assume you know what's slow → always read the execution plan before changing anything. 2. Optimize in small, targeted steps instead of rewriting the entire query to avoid breaking correctness. 3. Readable queries > Clever queries → if your 500-line CTE masterpiece confuses everyone, it's unmaintainable. 4. Understand the data distribution first → a query that works on 1M rows might explode on 1B rows with skewed data. 5. Query optimization is a habit → review slow queries continuously, not just when the CEO complains the dashboard is frozen. 6. Simplify, don't complicate → sometimes removing a subquery or unnecessary join is all you need. 7. Focus on data layout, not just SQL tricks → proper partitioning and clustering beats query rewrites every time. 8. Reduce data scanned → scanning less data is always faster and cheaper than scanning everything with a better algorithm. 9. Performance matters more than you think → a query taking 10 minutes vs 10 seconds is the difference between interactive analytics and batch hell. 10. Legacy queries aren't scary → but optimizing them without understanding the business logic is a nightmare. 11. Don't change too much at once → rewriting joins, adding indexes, and changing partitions simultaneously makes debugging impossible. 12. Know your goal before optimizing → lower latency? Reduce cost? Handle more concurrency? Define it first. 13. Favor filters early over filters late → push predicates down to scan less data, don't scan everything then filter. 14. Indexes aren't always your friend → they speed up reads but slow down writes, and they cost storage. Use them strategically. 15. Optimize what runs most often → a query running 10,000 times/day with 5-second latency wastes more resources than a 1-hour monthly report. 16. Queries are for humans too → write them so your future self (and your team) can understand the logic without a PhD. 17. Slow queries are a liability → ignoring them today means angry users, blown SLAs, and expensive compute bills tomorrow.

These were the optimizations I used to save $5k a month on a SQL query (learning them are pretty useful across many databases) I spend a lot of time optimizing SQL queries for data pipelines and dashboards, and I keep seeing the same performance killers over and over. Queries that should run in seconds take minutes, and teams don't realize why until I dig into the execution plans. Here are the most expensive gotchas I've found: 1. Using SELECT * in production queries - I see this constantly in ETL pipelines. You're pulling columns you don't need, bloating memory usage and network transfer. Always specify exact columns, especially in large tables or frequent queries. 2. Filtering after aggregation instead of before - I find this pattern everywhere. Moving WHERE clauses before GROUP BY can reduce the dataset by orders of magnitude before expensive operations run. 3. Using complex functions in WHERE clauses - Wrapping columns in complex functions prevents some query optimizations like predicate push down sometimes. 4. Unnecessary DISTINCT operations - Teams add DISTINCT as a quick fix for duplicate data, but it masks underlying data quality issues and forces expensive deduplication operations. 5. Using ORDER BY on transform pipelines - While sometimes those are legit for optimization purposes (bucketing or clustering), most times these are no-ops on transformation pipelines and just burn $$ 6. Not understanding your database's query planner - Each platform I work with (Snowflake, BigQuery, PostgreSQL) optimizes queries differently. Learning your specific system's behavior is crucial. The impact compounds quickly in my experience. A query that takes 5 minutes instead of 30 seconds might not seem terrible, but when it runs hourly in production pipelines or as part of a dashboard with 20 charts that 30% of the employees refresh daily, you're burning compute resources and slowing down dependent processes. The real win isn't just faster queries. When I optimize SQL, I'm reducing compute costs, keeping dashboards responsive for end users, and making sure pipelines don't break when data volume doubles. What's your experience with SQL performance issues? Share in the comments, follow for more insights on data engineering, and ♻️ repost if your network could benefit! #SQL #DataEngineering #QueryOptimization #DatabasePerformance #DataStrategy

SQL Query Optimization Best Practices Optimizing SQL queries in SQL Server is crucial for improving performance and ensuring efficient use of database resources. Here are some best practices for SQL query optimization in SQL Server: 1). Use Indexes Wisely: a. Identify frequently used columns in WHERE, JOIN, and ORDER BY clauses and create appropriate indexes on those columns. b. Avoid over-indexing as it can degrade insert and update performance. c. Regularly monitor index usage and performance to ensure they are providing benefits. 2). Write Efficient Queries: a. Minimize the use of wildcard characters, especially at the beginning of LIKE patterns, as it prevents the use of indexes. b. Use EXISTS or IN instead of DISTINCT or GROUP BY when possible. c. Avoid using SELECT * and fetch only the necessary columns. d. Use UNION ALL instead of UNION if you don't need to remove duplicate rows, as it is faster. e. Use JOINs instead of subqueries for better performance. f. Avoid using scalar functions in WHERE clauses as they can prevent index usage. 3). Optimize Joins: a. Use INNER JOIN instead of OUTER JOIN if possible, as INNER JOIN typically performs better. b. Ensure that join columns are indexed for better join performance. c. Consider using table hints like (NOLOCK) if consistent reads are not required, but use them cautiously as they can lead to dirty reads. 4). Avoid Cursors and Loops: a. Use set-based operations instead of cursors or loops whenever possible. b. Cursors can be inefficient and lead to poor performance, especially with large datasets. 5). Use Query Execution Plan: a. Analyze query execution plans using tools like SQL Server Management Studio (SSMS) or SQL Server Profiler to identify bottlenecks and optimize queries accordingly. b. Look for missing indexes, expensive operators, and table scans in execution plans. 6). Update Statistics Regularly: a. Keep statistics up-to-date by regularly updating them using the UPDATE STATISTICS command or enabling the auto-update statistics feature. b. Updated statistics help the query optimizer make better decisions about query execution plans. 7. Avoid Nested Queries: a. Nested queries can be harder for the optimizer to optimize effectively. b. Consider rewriting them as JOINs or using CTEs (Common Table Expressions) if possible. 8. Partitioning: a. Consider partitioning large tables to improve query performance, especially for queries that access a subset of data based on specific criteria. 9. Use Stored Procedures: a. Encapsulate frequently executed queries in stored procedures to promote code reusability and optimize query execution plans. 10). Regular Monitoring and Tuning: a. Continuously monitor database performance using SQL Server tools or third-party monitoring solutions. b. Regularly review and tune queries based on performance metrics and user feedback.  #sqlserver #performancetuning #database #mssql

With a background in data engineering and business analysis, I’ve consistently seen the immense impact of optimized SQL code on improving the performance and efficiency of database operations. It indirectly contributes to cost savings by reducing resource consumption. Here are some techniques that have proven invaluable in my experience: 1. Index Large Tables: Indexing tables with large datasets (>1,000,000 rows) greatly speeds up searches and enhances query performance. However, be cautious of over-indexing, as excessive indexes can degrade write operations. 2. Select Specific Fields: Choosing specific fields instead of using SELECT * reduces the amount of data transferred and processed, which improves speed and efficiency. 3. Replace Subqueries with Joins: Using joins instead of subqueries in the WHERE clause can improve performance. 4. Use UNION ALL Instead of UNION: UNION ALL is preferable over UNION because it does not involve the overhead of sorting and removing duplicates. 5. Optimize with WHERE Instead of HAVING: Filtering data with WHERE clauses before aggregation operations reduces the workload and speeds up query processing. 6. Utilize INNER JOIN Instead of WHERE for Joins: INNER JOINs help the query optimizer make better execution decisions than complex WHERE conditions. 7. Minimize Use of OR in Joins: Avoiding the OR operator in joins enhances performance by simplifying the conditions and potentially reducing the dataset earlier in the execution process. 8. Use Views: Creating views instead of results that can be accessed faster than recalculating the views each time they are needed. 9. Minimize the Number of Subqueries: Reducing the number of subqueries in your SQL statements can significantly enhance performance by decreasing the complexity of the query execution plan and reducing overhead. 10. Implement Partitioning: Partitioning large tables can improve query performance and manageability by logically dividing them into discrete segments. This allows SQL queries to process only the relevant portions of data. #SQL #DataOptimization #DatabaseManagement #PerformanceTuning #DataEngineering

5 𝗦𝗤𝗟 𝗧𝗿𝗶𝗰𝗸𝘀 𝘁𝗼 𝗠𝗮𝗸𝗲 𝗬𝗼𝘂𝗿 𝗪𝗼𝗿𝗸 𝗙𝗮𝘀𝘁𝗲𝗿 𝗮𝗻𝗱 𝗖𝗹𝗲𝗮𝗻𝗲𝗿 Working with SQL doesn’t have to feel like a guessing game. Here are five technical SQL tricks that can help you streamline complex queries and optimize performance: 1. 𝗕𝗿𝗲𝗮𝗸 𝗗𝗼𝘄𝗻 𝗖𝗼𝗺𝗽𝗹𝗲𝘅 𝗤𝘂𝗲𝗿𝗶𝗲𝘀 𝘄𝗶𝘁𝗵 𝗖𝗧𝗘𝘀: Use Common Table Expressions (CTEs) to create temporary result sets within a query. CTEs improve readability and allow you to build logical steps. 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 - WITH SalesSummary AS ( SELECT customer_id, SUM(sales_amount) AS total_sales FROM Sales GROUP BY customer_id ) SELECT * FROM SalesSummary WHERE total_sales > 5000; 2. 𝗔𝗱𝗱 𝗜𝗻𝗱𝗲𝘅𝗲𝘀 𝘁𝗼 𝗕𝗼𝗼𝘀𝘁 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲: Creating indexes on frequently joined or filtered columns can drastically reduce query time by helping the database locate rows faster. 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 - CREATE INDEX idx_customer_id ON Orders (customer_id); 3. 𝗨𝘀𝗲 𝗜𝗡𝗡𝗘𝗥 𝘃𝘀. 𝗟𝗘𝗙𝗧 𝗝𝗢𝗜𝗡 𝗪𝗶𝘀𝗲𝗹𝘆: Understanding join types prevents unexpected data loss. For instance, use INNER JOIN when you only want matching records from both tables, and LEFT JOIN when you want to keep all records from the left table regardless of matches. 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 - SELECT Orders.order_id, Customers.name FROM Orders LEFT JOIN Customers ON Orders.customer_id = Customers.customer_id; 4. 𝗘𝘅𝗽𝗹𝗼𝗿𝗲 𝗪𝗶𝗻𝗱𝗼𝘄 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 𝗳𝗼𝗿 𝗔𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀: Window functions like ROW_NUMBER(), RANK(), and SUM() enable calculations across a set of rows related to the current row without needing additional joins. 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 - SELECT order_id, amount, SUM(amount) OVER (ORDER BY order_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS running_total FROM Orders; 5. 𝗙𝗶𝗹𝘁𝗲𝗿 𝘄𝗶𝘁𝗵 𝗛𝗔𝗩𝗜𝗡𝗚, 𝗡𝗼𝘁 𝗪𝗛𝗘𝗥𝗘, 𝗔𝗳𝘁𝗲𝗿 𝗔𝗴𝗴𝗿𝗲𝗴𝗮𝘁𝗲𝘀: Use the HAVING clause to filter aggregated data in GROUP BY queries, as WHERE cannot be applied to aggregate functions. 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 - SELECT customer_id, COUNT(order_id) AS total_orders FROM Orders GROUP BY customer_id HAVING total_orders > 10; These small adjustments can make a huge difference in query efficiency and accuracy. What’s one SQL trick that’s helped you the most?"

𝐌𝐚𝐬𝐭𝐞𝐫𝐢𝐧𝐠 𝐐𝐮𝐞𝐫𝐲 𝐎𝐩𝐭𝐢𝐦𝐢𝐳𝐚𝐭𝐢𝐨𝐧 𝐢𝐧 𝐒𝐐𝐋: 𝐒𝐭𝐞𝐩-𝐛𝐲-𝐒𝐭𝐞𝐩 𝐆𝐮𝐢𝐝𝐞 Query optimization is a key skill for improving the performance of SQL queries, ensuring that your database runs efficiently. Here’s a step-by-step guide on how to optimize SQL queries, along with examples to illustrate each step: ↳ 𝐔𝐬𝐞 𝐈𝐧𝐝𝐞𝐱𝐞𝐬 𝐄𝐟𝐟𝐞𝐜𝐭𝐢𝐯𝐞𝐥𝐲: Indexing speeds up data retrieval. Identify columns frequently used in WHERE, JOIN, and ORDER BY clauses and create indexes accordingly. CREATE INDEX idx_column_name ON table_name (column_name); ↳ 𝐎𝐩𝐭𝐢𝐦𝐢𝐳𝐞 𝐉𝐨𝐢𝐧𝐬: Use appropriate join types (INNER JOIN, LEFT JOIN, etc.), and ensure indexes exist on join keys for better performance. SELECT a.column1, b.column2 FROM table_a a INNER JOIN table_b b ON a.id = b.a_id; ↳ 𝐀𝐯𝐨𝐢𝐝 𝐒𝐄𝐋𝐄𝐂𝐓: Select only required columns instead of SELECT * to reduce data retrieval time. SELECT column1, column2 FROM table_name; ↳ 𝐔𝐬𝐞 𝐖𝐇𝐄𝐑𝐄 𝐈𝐧𝐬𝐭𝐞𝐚𝐝 𝐨𝐟 𝐇𝐀𝐕𝐈𝐍𝐆: WHERE filters records before aggregation, while HAVING filters after, making WHERE more efficient in many cases. SELECT column1, COUNT(*) FROM table_name WHERE column2 = 'value' GROUP BY column1; ↳ 𝐋𝐞𝐯𝐞𝐫𝐚𝐠𝐞 𝐂𝐚𝐜𝐡𝐢𝐧𝐠 𝐚𝐧𝐝 𝐌𝐚𝐭𝐞𝐫𝐢𝐚𝐥𝐢𝐳𝐞𝐝 𝐕𝐢𝐞𝐰𝐬: Store precomputed results to improve performance for complex queries. CREATE MATERIALIZED VIEW view_name AS SELECT column1, column2 FROM table_name; ↳ 𝐏𝐚𝐫𝐭𝐢𝐭𝐢𝐨𝐧 𝐋𝐚𝐫𝐠𝐞 𝐓𝐚𝐛𝐥𝐞𝐬: Partitioning helps break down large tables into smaller chunks, improving query performance. CREATE TABLE table_name ( id INT, column1 TEXT, created_at DATE ) PARTITION BY RANGE (created_at); ↳ 𝐔𝐬𝐞 𝐄𝐗𝐏𝐋𝐀𝐈𝐍 𝐏𝐋𝐀𝐍 𝐭𝐨 𝐀𝐧𝐚𝐥𝐲𝐳𝐞 𝐐𝐮𝐞𝐫𝐢𝐞𝐬: Identify bottlenecks and optimize queries accordingly. EXPLAIN ANALYZE SELECT column1 FROM table_name WHERE column2 = 'value'; ↳ 𝐎𝐩𝐭𝐢𝐦𝐢𝐳𝐞 𝐒𝐮𝐛𝐪𝐮𝐞𝐫𝐢𝐞𝐬 𝐰𝐢𝐭𝐡 𝐂𝐓𝐄𝐬: Use Common Table Expressions (CTEs) instead of nested subqueries for better readability and performance. WITH CTE AS ( SELECT column1, column2 FROM table_name WHERE column3 = 'value' ) SELECT * FROM CTE; Do you have any additional tips for query optimization? Drop them in the comments! 👇 𝐆𝐞𝐭 𝐭𝐡𝐞 𝐢𝐧𝐭𝐞𝐫𝐯𝐢𝐞𝐰 𝐜𝐚𝐥𝐥: https://lnkd.in/ges-e-7J 𝐉𝐨𝐢𝐧 𝐦𝐞: https://lnkd.in/giE3e9yH p.s: If you found this helpful, follow for more #DataEngineering insights!

𝗗𝗮𝘆 𝟰/𝟯𝟬 — 𝗦𝗤𝗟 𝗤𝘂𝗲𝗿𝘆 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻: 𝗧𝗵𝗲 𝗦𝗸𝗶𝗹𝗹 𝗧𝗵𝗮𝘁 𝗧𝘂𝗿𝗻𝘀 𝗚𝗼𝗼𝗱 𝗗𝗘𝘀 𝗶𝗻𝘁𝗼 𝗚𝗿𝗲𝗮𝘁 𝗗𝗘𝘀 👉 What People Think… “If the query works, that’s enough.” “Performance issues = server problem.” “Indexes magically speed everything up.” “SELECT * is harmless.” 👉 What Actually Happens… SQL performance depends on how efficiently your query interacts with data: filters → joins → indexes → scans → execution plans. The difference between a good query and a great query is often 10x speed. 🔟 𝗦𝗤𝗟 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻 𝗣𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀 𝗘𝘃𝗲𝗿𝘆 𝗗𝗮𝘁𝗮 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿 𝗠𝘂𝘀𝘁 𝗞𝗻𝗼𝘄 1️⃣ Use Indexes Smartly Indexes shine on high-cardinality columns. Don’t index everything — it slows writes. 2️⃣ Avoid SELECT * Selecting only required columns reduces scan time + network I/O. 3️⃣ Use EXISTS instead of IN (for large subqueries) EXISTS stops after the first match → usually faster. 4️⃣ Optimize JOINs using indexed keys Joining on unindexed columns is one of the biggest performance killers. 5️⃣ Filter Early (WHERE before GROUP BY/HAVING) Shrinking the dataset early = faster computation later. 6️⃣ Avoid functions on indexed columns WHERE DATE(timestamp) blocks index usage completely. 7️⃣ Prefer UNION ALL instead of UNION UNION = deduplication = expensive sorting. 8️⃣ Don’t do wildcard-leading searches LIKE '%text' → full scan. LIKE 'text%' → index friendly. 9️⃣ Partition large tables Especially for time-series data; improves pruning dramatically. 🔟 Always check the query plan (EXPLAIN) Most engineers don’t — but this shows WHERE the bottleneck really is. #dataengineering #sqlinterview #techinterviewprep #30daysofde

𝐒𝐨𝐦𝐞 𝐁𝐞𝐬𝐭 𝐩𝐫𝐚𝐜𝐭𝐢𝐜𝐞𝐬 𝐭𝐨 𝐡𝐞𝐥𝐩 𝐲𝐨𝐮 𝐨𝐩𝐭𝐢𝐦𝐢𝐳𝐞 𝐲𝐨𝐮𝐫 𝐒𝐐𝐋 𝐪𝐮𝐞𝐫𝐢𝐞𝐬: 1. Simplify Joins • Decompose complex joins into simpler, more manageable queries when possible. • Index columns that are used as foreign keys in joins to enhance join performance. 2. Query Structure Optimization • Apply WHERE clauses as early as possible to filter out rows before they are processed further. • Utilize LIMIT or TOP clauses to restrict the number of rows returned, which can significantly reduce processing time. 3. Partition Large Tables • Divide large tables into smaller, more manageable partitions. • Ensure that each partition is properly indexed to maintain query performance. 4. Optimize SELECT Statements • Limit the columns in your SELECT clause to only those you need. Avoid using SELECT * to prevent unnecessary data retrieval. • Prefer using EXISTS over IN for subqueries to improve query performance. 5. Use Temporary Tables Wisely • Temporary Tables: Use temporary tables to save intermediate results when you have a complex query. This helps break down a complicated query into simpler steps, making it easier to manage and faster to run. 6. Optimize Table Design • Normalize your database schema to eliminate redundant data and improve consistency. • Consider denormalization for read-heavy systems to reduce the number of joins needed. 7. Avoid Correlated Subqueries • Replace correlated subqueries with joins or use derived tables to improve performance. • Correlated subqueries can be very inefficient as they are executed multiple times. 8. Use Stored Procedures: • Put complicated database tasks into stored procedures. These are pre-written sets of instructions saved in the database. They make your queries run faster because the database doesn’t have to figure out how to execute them each time