get-smart 0.0.1

data/files/sql/general/middle/parameterized_queries_security.md

@@ -0,0 +1,10 @@
+## 🔒 Use Parameterized Queries to Prevent SQL Injection
+Instead of concatenating user inputs into SQL strings, use prepared statements or ORM placeholders to safely inject parameters. This protects your application from injection attacks and often improves performance due to query plan caching.
+
+```ruby
+# Using ActiveRecord
+User.where("email = ? AND active = ?", params[:email], true)
+
+# Using raw PG connection
+conn.exec_params("SELECT * FROM users WHERE id = $1", [user_id])
+```

data/files/sql/general/middle/query_plan_analysis.md

@@ -0,0 +1,10 @@
+## 🔎 Analyze Query Plans with EXPLAIN ANALYZE
+Before optimizing, inspect how PostgreSQL executes your query. `EXPLAIN ANALYZE` provides actual execution times and row counts, revealing bottlenecks like sequential scans or inefficient joins.
+
+```sql
+EXPLAIN ANALYZE
+SELECT *
+FROM customers c
+JOIN orders o ON o.customer_id = c.id
+WHERE c.country = 'CA';
+```

data/files/sql/general/middle/upsert_with_on_conflict.md

@@ -0,0 +1,11 @@
+## 🛠️ Handle Conflicts Gracefully with ON CONFLICT DO UPDATE
+Use the `ON CONFLICT` clause to perform upserts (insert or update) in a single statement, avoiding separate existence checks and race conditions.
+
+```sql
+INSERT INTO users (email, name, login_count)
+VALUES ('jane@example.com', 'Jane', 1)
+ON CONFLICT (email)
+DO UPDATE SET
+  name = EXCLUDED.name,
+  login_count = users.login_count + 1;
+```

data/files/sql/general/middle/window_functions_usage.md

@@ -0,0 +1,12 @@
+## 📊 Leverage Window Functions for Running Totals and Rankings
+Window functions allow calculations across a set of rows related to the current row without collapsing the result set. Use `OVER` clauses to compute running totals, rankings, or moving averages.
+
+```sql
+SELECT
+  order_id,
+  order_date,
+  amount,
+  SUM(amount) OVER (ORDER BY order_date) AS running_total,
+  RANK() OVER (PARTITION BY customer_id ORDER BY amount DESC) AS rank_by_amount
+FROM orders;
+```

data/files/sql/mysql/advanced/cte_recursive.md

@@ -0,0 +1,13 @@
+## 🔄 Simplify Hierarchical Queries with Recursive CTEs
+Recursive CTEs let you traverse trees or graphs elegantly without multiple self-joins. They work by defining an anchor member and a recursive member. Use them for org charts, bill-of-materials explosions, or hierarchical permissions.
+
+```sql
+WITH RECURSIVE ceo_chain (id, manager_id, level) AS (
+  SELECT id, manager_id, 1 FROM employees WHERE manager_id IS NULL
+  UNION ALL
+  SELECT e.id, e.manager_id, c.level + 1
+  FROM employees e
+  JOIN ceo_chain c ON e.manager_id = c.id
+)
+SELECT * FROM ceo_chain;
+```

data/files/sql/mysql/advanced/explain_analyze.md

@@ -0,0 +1,10 @@
+## 🔍 Use EXPLAIN ANALYZE for Accurate Costing
+Running EXPLAIN ANALYZE executes the query and returns real execution metrics, including actual row counts and timing. This helps identify costly operations and misestimated cardinalities that a simple EXPLAIN may miss. Use these insights to adjust indexes, rewrite joins, or refactor subqueries.
+
+```sql
+EXPLAIN ANALYZE
+SELECT user_id, COUNT(*)
+FROM orders
+WHERE created_at > '2023-01-01'
+GROUP BY user_id;
+```

data/files/sql/mysql/advanced/fulltext_boolean_weights.md

@@ -0,0 +1,13 @@
+## 🔎 Boost Full-Text Search Precision with Boolean Mode and Weighting
+Boolean full-text searches let you include/exclude terms and use wildcards. You can also assign custom weights by indexing critical columns separately and combining MATCH() scores. This yields relevance ranking tailored to your business needs.
+
+```sql
+ALTER TABLE articles ADD FULLTEXT INDEX ft_title_content (title, content);
+
+SELECT
+  id,
+  MATCH(title, content) AGAINST('+database -NoSQL' IN BOOLEAN MODE) AS score
+FROM articles
+WHERE MATCH(title, content) AGAINST('+database -NoSQL' IN BOOLEAN MODE)
+ORDER BY score DESC;
+```

data/files/sql/mysql/advanced/generated_columns.md

@@ -0,0 +1,9 @@
+## ⚙️ Leverage Generated Columns for Computed Values
+Generated columns allow you to index expressions and JSON extractions as real columns. Choose STORED for frequent lookups or VIRTUAL for space savings. This technique can accelerate filters and grouping queries without manual maintenance.
+
+```sql
+ALTER TABLE orders
+ADD COLUMN total_cents INT
+  GENERATED ALWAYS AS (amount * 100) STORED,
+ADD INDEX idx_total_cents (total_cents);
+```

data/files/sql/mysql/advanced/json_functions.md

@@ -0,0 +1,10 @@
+## 🗄️ Efficiently Query JSON Data with JSON_EXTRACT and JSON_OVERLAPS
+MySQL’s JSON functions let you store semi-structured data while still indexing key paths via generated columns. Use JSON_EXTRACT to pull nested values, and JSON_OVERLAPS to filter arrays efficiently. Combine them with indexes on generated columns to keep performance predictable.
+
+```sql
+SELECT
+  id,
+  JSON_EXTRACT(metadata, '$.preferences.theme') AS theme
+FROM users
+WHERE JSON_OVERLAPS(tags, JSON_ARRAY('premium','beta_tester'));
+```

data/files/sql/mysql/advanced/partitioning_range.md

@@ -0,0 +1,11 @@
+## 🗂️ Scale Large Tables with Range Partitioning
+Range partitioning breaks a table into smaller segments based on key values, reducing scan times. You can also subpartition for multi-dimensional partitioning. Ensure your WHERE clauses filter on the partition key to benefit from partition pruning.
+
+```sql
+ALTER TABLE logs
+PARTITION BY RANGE (YEAR(created_at)) (
+  PARTITION p2021 VALUES LESS THAN (2022),
+  PARTITION p2022 VALUES LESS THAN (2023),
+  PARTITION pmax VALUES LESS THAN MAXVALUE
+);
+```

data/files/sql/mysql/advanced/performance_schema.md

@@ -0,0 +1,14 @@
+## 📈 Profile Slow Queries Using performance_schema
+The performance_schema lets you collect fine-grained metrics on statements, stages, and waits. Enable the desired consumers and instruments, then query summary tables for the top offenders. Use these insights to rewrite or index slow queries.
+
+```sql
+-- Enable statement instrumentation
+UPDATE performance_schema.setup_consumers
+SET ENABLED = 'YES'
+WHERE NAME = 'statements_digest';
+
+SELECT *
+FROM performance_schema.events_statements_summary_by_digest
+ORDER BY SUM_TIMER_WAIT DESC
+LIMIT 10;
+```

data/files/sql/mysql/advanced/spatial_index.md

@@ -0,0 +1,15 @@
+## 🌐 Optimize Geospatial Queries with SPATIAL Indexes
+MySQL’s SPATIAL indexes speed up geometric queries on supported data types like POINT and POLYGON. Combine them with functions like ST_Distance_Sphere for great performance on location-based searches. Ensure your MySQL engine supports MyISAM or InnoDB SPATIAL indexing.
+
+```sql
+ALTER TABLE locations
+ADD COLUMN geom POINT NOT NULL,
+ADD SPATIAL INDEX sp_idx_geom (geom);
+
+SELECT id, name
+FROM locations
+WHERE ST_Distance_Sphere(
+  geom,
+  ST_GeomFromText('POINT(-73.9857 40.7484)')
+) < 5000;
+```

data/files/sql/mysql/advanced/transaction_isolation.md

@@ -0,0 +1,10 @@
+## 🔒 Fine-Tune Locking with Custom Transaction Isolation Levels
+Choosing the right isolation level balances consistency and concurrency. SERIALIZABLE prevents phantom reads but can increase locking waits, while READ COMMITTED reduces them. Use SELECT ... FOR UPDATE or LOCK IN SHARE MODE to explicitly lock rows when needed.
+
+```sql
+SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
+START TRANSACTION;
+SELECT * FROM inventory WHERE product_id = 42 FOR UPDATE;
+UPDATE inventory SET stock = stock - 1 WHERE product_id = 42;
+COMMIT;
+```

data/files/sql/mysql/advanced/window_running_total.md

@@ -0,0 +1,10 @@
+## 📊 Calculate Running Totals with Window Functions
+Window functions let you compute cumulative aggregates without self-joins or variables. For instance, you can get a running total of sales per user by partitioning by user_id and ordering by date. This approach is both concise and performant in MySQL 8+.
+
+```sql
+SELECT
+  order_id,
+  order_date,
+  SUM(amount) OVER (PARTITION BY user_id ORDER BY order_date) AS running_total
+FROM orders;
+```

data/files/sql/mysql/beginner/count_aggregate.md

@@ -0,0 +1,13 @@
+## 🧮 Using COUNT to Aggregate Data
+`COUNT()` returns the number of rows that match a condition. It’s useful for summary reports and dashboards.
+
+```sql
+-- Count total users
+SELECT COUNT(*) AS total_users
+FROM users;
+
+-- Count active orders
+SELECT COUNT(*) AS active_orders
+FROM orders
+WHERE status = 'active';
+```

data/files/sql/mysql/beginner/delete_records.md

@@ -0,0 +1,13 @@
+## ❌ Deleting Records with DELETE
+`DELETE` removes rows from a table. Use `WHERE` to limit deletions or combine with `LIMIT` for cautious cleanup.
+
+```sql
+-- Delete a single order by its ID
+DELETE FROM orders
+WHERE id = 1001;
+
+-- Delete up to 10 old logs
+DELETE FROM logs
+WHERE created_at < '2022-01-01'
+LIMIT 10;
+```

data/files/sql/mysql/beginner/filter_with_where.md

@@ -0,0 +1,13 @@
+## 📝 Filtering with WHERE
+The `WHERE` clause lets you return only rows that meet specified conditions. Combine operators (`=`, `<`, `>`, `LIKE`) to narrow results.
+
+```sql
+SELECT id, name, email
+FROM users
+WHERE active = 1;
+
+-- Using LIKE for pattern matching
+SELECT *
+FROM products
+WHERE name LIKE 'Apple%';
+```

data/files/sql/mysql/beginner/group_by_results.md

@@ -0,0 +1,10 @@
+## 📊 Grouping Results with GROUP BY
+`GROUP BY` groups rows sharing a property so you can apply aggregate functions like `SUM`, `AVG`, or `COUNT` per group.
+
+```sql
+-- Total sales per month
+SELECT DATE_FORMAT(order_date, '%Y-%m') AS month,
+       SUM(total) AS monthly_sales
+FROM orders
+GROUP BY month;
+```

data/files/sql/mysql/beginner/inner_join.md

@@ -0,0 +1,9 @@
+## 🔗 Combining Tables with INNER JOIN
+`INNER JOIN` returns rows with matching values in both tables. It's ideal for fetching related records.
+
+```sql
+SELECT orders.id, users.name, orders.total
+FROM orders
+INNER JOIN users
+  ON orders.user_id = users.id;
+```

data/files/sql/mysql/beginner/insert_data.md

@@ -0,0 +1,14 @@
+## ➕ Inserting Data with INSERT INTO
+`INSERT INTO` adds new rows to a table. Specify the columns and values to ensure data integrity.
+
+```sql
+-- Insert a single user
+INSERT INTO users (name, email, active)
+VALUES ('Alice', 'alice@example.com', 1);
+
+-- Insert multiple products
+INSERT INTO products (name, price)
+VALUES
+  ('Phone', 699.99),
+  ('Laptop', 1299.50);
+```

data/files/sql/mysql/beginner/limit_results.md

@@ -0,0 +1,14 @@
+## 🎯 Using LIMIT to Restrict Rows
+`LIMIT` restricts the number of rows returned by a query. It's useful for pagination or previewing data.
+
+```sql
+-- Return only the first 5 users
+SELECT id, name
+FROM users
+LIMIT 5;
+
+-- Skip the first 10 and return the next 5
+SELECT *
+FROM orders
+LIMIT 10, 5;
+```

data/files/sql/mysql/beginner/order_by_clause.md

@@ -0,0 +1,14 @@
+## 📑 Ordering Results with ORDER BY
+`ORDER BY` sorts query results by one or more columns. Use `ASC` for ascending or `DESC` for descending order.
+
+```sql
+-- Sort users by creation date descending
+SELECT id, name, created_at
+FROM users
+ORDER BY created_at DESC;
+
+-- Sort products by price ascending, then name
+SELECT *
+FROM products
+ORDER BY price ASC, name ASC;
+```

data/files/sql/mysql/beginner/select_all_columns.md

@@ -0,0 +1,7 @@
+## 🔍 Selecting All Columns
+Use `SELECT *` to retrieve all columns from a table. This is helpful for quick inspections, but avoid in production queries to limit data transfer.
+
+```sql
+SELECT *
+FROM users;
+```

data/files/sql/mysql/beginner/update_records.md

@@ -0,0 +1,14 @@
+## 🔄 Updating Records with UPDATE
+`UPDATE` modifies existing rows. Always include a `WHERE` clause to avoid changing all rows unintentionally.
+
+```sql
+-- Deactivate a user by ID
+UPDATE users
+SET active = 0
+WHERE id = 42;
+
+-- Increase price of all accessories by 10%
+UPDATE products
+SET price = price * 1.10
+WHERE category = 'Accessory';
+```

data/files/sql/mysql/expert/advanced_partition_pruning.md

@@ -0,0 +1,18 @@
+## 🚧 Fine-Tune Partition Pruning with Expression Partitions
+
+Partitioning by expressions (e.g., `TO_DAYS(date) DIV 7`) can group data by week, month, or custom buckets. Ensure your WHERE clause matches the partition expression to enable pruning. Use `EXPLAIN PARTITIONS` to verify pruned partitions.
+
+```sql
+CREATE TABLE metrics (
+  ts DATETIME,
+  value DOUBLE
+)
+PARTITION BY RANGE (YEAR(ts)) (
+  PARTITION p2022 VALUES LESS THAN (2023),
+  PARTITION p2023 VALUES LESS THAN (2024)
+);
+
+EXPLAIN PARTITIONS SELECT *
+FROM metrics
+WHERE ts BETWEEN '2023-05-01' AND '2023-06-01';
+```

data/files/sql/mysql/expert/extended_statistics_multicolumn_selectivity.md

@@ -0,0 +1,14 @@
+## 📊 Create Extended Statistics for Better Multi-Column Plans
+
+Standard single-column histograms can misestimate row counts for combined filters. MySQL’s extended statistics let you track correlation and distinct counts across multiple columns, improving join and range query selectivity.
+
+```sql
+CREATE STATISTICS stat_user_region_age
+  ON users (region_id, age)
+  COMMENT 'Track correlation for region and age';
+ANALYZE TABLE users;
+
+EXPLAIN SELECT *
+FROM users
+WHERE region_id = 5 AND age BETWEEN 30 AND 40;
+```

data/files/sql/mysql/expert/generated_columns_json_optimization.md

@@ -0,0 +1,13 @@
+## 🥡 Optimize JSON with Generated Columns and Indexes
+
+Storing JSON in MySQL is flexible but slow for searching. Define virtual or stored generated columns to extract JSON keys, then index them for lightning-fast lookups. Stored columns persist on disk; virtual are computed on demand.
+
+```sql
+ALTER TABLE events
+  ADD COLUMN event_type VARCHAR(50)
+    AS (JSON_UNQUOTE(JSON_EXTRACT(payload, '$.type'))) STORED,
+  ADD INDEX idx_event_type (event_type);
+
+SELECT * FROM events
+WHERE event_type = 'user_signup';
+```

data/files/sql/mysql/expert/invisible_indexes_testing.md

@@ -0,0 +1,18 @@
+## 🔍 Use Invisible Indexes for Safe Index Tuning
+
+Invisible indexes (MySQL 8.0+) let you disable an index without dropping it, to test its impact on plan stability and performance. Convert an index to invisible, monitor performance via `EXPLAIN`, and revert if needed.
+
+```sql
+-- Make index invisible
+ALTER TABLE orders
+  ALTER INDEX idx_customer_date INVISIBLE;
+
+-- Test query plans
+EXPLAIN SELECT *
+FROM orders
+WHERE customer_id = 42 AND order_date > '2023-01-01';
+
+-- Revert if performance regresses
+ALTER TABLE orders
+  ALTER INDEX idx_customer_date VISIBLE;
+```

data/files/sql/mysql/expert/optimizer_hints_query_forcing.md

@@ -0,0 +1,13 @@
+## 💡 Force Join Order and Access with Optimizer Hints
+
+When the optimizer picks a suboptimal plan, use hints like `STRAIGHT_JOIN`, `USE INDEX`, or `FORCE INDEX` to override defaults. Hints should be your last resort and guarded by feature flags or comments.
+
+```sql
+SELECT /*+ NO_RANGE_OPTIMIZATION(t1) */
+  t1.id, t2.details
+FROM table1 AS t1
+STRAIGHT_JOIN table2 AS t2
+  USE INDEX (idx_details)
+  ON t1.ref = t2.id
+WHERE t2.status = 'active';
+```

data/files/sql/mysql/expert/performance_schema_query_profiling.md

@@ -0,0 +1,18 @@
+## 🔧 Profile Slow Queries with performance_schema Events
+
+Use `performance_schema` to capture detailed timing, I/O, and wait events without external tools. Enable relevant instruments, capture data into tables, and join with `events_statements_history` to pinpoint hotspots.
+
+```sql
+UPDATE performance_schema.setup_instruments
+SET ENABLED = 'YES', TIMED = 'YES'
+WHERE NAME LIKE 'statement/%';
+
+SELECT esh.SQL_TEXT,
+       esh.TIMER_WAIT AS nanoseconds,
+       io.COUNT_STAR AS io_operations
+FROM performance_schema.events_statements_history esh
+JOIN performance_schema.events_waits_summary_global_by_event_name io
+  ON esh.EVENT_ID = io.EVENT_ID
+ORDER BY esh.TIMER_WAIT DESC
+LIMIT 10;
+```

data/files/sql/mysql/expert/recursive_cte_hierarchies.md

@@ -0,0 +1,16 @@
+## 🌳 Recursive CTEs for Hierarchical Data
+
+Recursive Common Table Expressions (CTEs) let you traverse trees and graphs natively, avoiding stored procedures. Use `WITH RECURSIVE` to join parent-child rows iteratively, controlling cycle detection and max depth.
+
+```sql
+WITH RECURSIVE employee_hierarchy AS (
+  SELECT id, manager_id, name, 1 AS depth
+  FROM employees
+  WHERE manager_id IS NULL
+  UNION ALL
+  SELECT e.id, e.manager_id, e.name, eh.depth + 1
+  FROM employees e
+  JOIN employee_hierarchy eh ON e.manager_id = eh.id
+)
+SELECT * FROM employee_hierarchy;
+```

data/files/sql/mysql/expert/user_defined_functions_extending.md

@@ -0,0 +1,30 @@
+## 🏗️ Extend MySQL with User-Defined Functions (UDFs)
+
+When built-in functions aren’t enough, UDFs let you add C/C++ routines to MySQL’s plugin API. Write, compile, and install a shared library to implement custom string manipulations, math functions, or data transforms at the server level.
+
+```c
+// example: my_reverse.c
+typedef char *(*fn_reverse)(char *);
+my_bool reverse_init(UDF_INIT *initid, UDF_ARGS *args, char *message) {
+  if (args->arg_count != 1) {
+    strcpy(message, "Wrong number of arguments");
+    return 1;
+  }
+  return 0;
+}
+
+char *reverse(UDF_INIT *initid, UDF_ARGS *args, char *result,
+              unsigned long *length, char *is_null, char *error) {
+  char *s = args->args[0];
+  size_t len = strlen(s);
+  for (size_t i = 0; i < len; ++i) result[i] = s[len - i - 1];
+  *length = len;
+  return result;
+}
+```
+
+```sql
+-- Install UDF
+CREATE FUNCTION reverse RETURNS STRING SONAME 'my_reverse.so';
+SELECT reverse('MySQL');  -- 'LSQyM'
+```

data/files/sql/mysql/expert/window_functions_running_totals.md

@@ -0,0 +1,16 @@
+## 🧮 Leverage Window Functions for Running Totals
+
+Window functions in MySQL 8.0+ let you compute running totals, moving averages, and differences without self-joins or subqueries. They’re optimized in C and can dramatically simplify complex analytics queries. Use `OVER` with ordering and frame clauses to control the window.
+
+```sql
+SELECT
+  order_date,
+  order_amount,
+  SUM(order_amount) OVER (
+    PARTITION BY customer_id
+    ORDER BY order_date
+    ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+  ) AS running_total
+FROM orders
+WHERE order_date >= '2023-01-01';
+```

data/files/sql/mysql/middle/ctes_common_table_expressions.md

@@ -0,0 +1,14 @@
+## 🧩 Simplifying Complex Queries with CTEs (WITH)
+Common Table Expressions (`WITH`) improve readability by breaking down complex queries into named subqueries. They can be recursive for hierarchical data retrieval. Each CTE can be referenced multiple times within the main query.
+
+```sql
+WITH recent_orders AS (
+  SELECT * FROM orders WHERE created_at > '2023-01-01'
+),
+total_per_customer AS (
+  SELECT customer_id, COUNT(*) AS cnt FROM recent_orders GROUP BY customer_id
+)
+SELECT c.name, t.cnt
+FROM total_per_customer t
+JOIN customers c ON c.id = t.customer_id;
+```

data/files/sql/mysql/middle/explain_query.md

@@ -0,0 +1,9 @@
+## 🔎 Using EXPLAIN to Analyze Query Performance
+Use the `EXPLAIN` statement to get insight into how MySQL executes your queries. This helps you identify table scans, index usage, and join strategies. By reviewing the output, you can adjust indexes or rewrite queries for better performance.
+
+```sql
+EXPLAIN SELECT orders.id, customers.name
+FROM orders
+JOIN customers ON orders.customer_id = customers.id
+WHERE orders.created_at > '2023-01-01';
+```

data/files/sql/mysql/middle/fulltext_search.md

@@ -0,0 +1,10 @@
+## 🗂️ Implementing Full-Text Search for Natural Language Queries
+Full-text indexes allow efficient searching for words or phrases in text columns using `MATCH ... AGAINST`. You can perform boolean searches or natural language ranking. Ensure you set appropriate minimum word length and stopwords.
+
+```sql
+ALTER TABLE articles ADD FULLTEXT(title, body);
+
+SELECT *, MATCH(title, body) AGAINST('database optimization' IN NATURAL LANGUAGE MODE) AS score
+FROM articles
+WHERE MATCH(title, body) AGAINST('database optimization');
+```

data/files/sql/mysql/middle/group_concat_usage.md

@@ -0,0 +1,11 @@
+## 🔗 Aggregating Strings with GROUP_CONCAT
+`GROUP_CONCAT` concatenates non-null values from a group into a single string. You can set `SEPARATOR` and limit the maximum length via `group_concat_max_len`. Useful for generating comma-separated lists of related items.
+
+```sql
+SELECT
+  o.order_id,
+  GROUP_CONCAT(p.name ORDER BY p.name SEPARATOR ', ') AS products
+FROM order_items oi
+JOIN products p ON oi.product_id = p.id
+GROUP BY o.order_id;
+```

data/files/sql/mysql/middle/index_usage.md

@@ -0,0 +1,7 @@
+## 📚 Creating and Analyzing Indexes for Faster Reads
+Indexes dramatically speed up lookups but slow down writes, so choose columns wisely. After creating an index, verify its usage with `SHOW INDEX` or `EXPLAIN`. Be cautious of over-indexing; focus on columns in `WHERE`, `JOIN`, and `ORDER BY` clauses.
+
+```sql
+CREATE INDEX idx_orders_date ON orders(created_at);
+SHOW INDEX FROM orders;
+```

data/files/sql/mysql/middle/json_functions.md

@@ -0,0 +1,12 @@
+## 📦 Querying and Modifying JSON Columns
+MySQL’s JSON data type stores semi-structured data; use functions like `JSON_EXTRACT`, `JSON_SET`, and `JSON_CONTAINS` to read or update nested values. Index JSON paths with generated columns for faster lookups.
+
+```sql
+-- Extract nested value
+SELECT JSON_EXTRACT(meta, '$.preferences.theme') AS theme
+FROM users;
+
+-- Update JSON field
+UPDATE users
+SET meta = JSON_SET(meta, '$.preferences.theme', 'dark');
+```

data/files/sql/mysql/middle/limit_offset_performance.md

@@ -0,0 +1,13 @@
+## ⏭️ Efficient Pagination with LIMIT and OFFSET
+`LIMIT offset, count` helps paginate results but large offsets can be slow. For deep pagination, use keyset pagination by filtering on the last seen value. This avoids scanning skipped rows and improves performance on large datasets.
+
+```sql
+-- Offset pagination
+SELECT * FROM posts ORDER BY created_at DESC LIMIT 1000, 20;
+
+-- Keyset pagination
+SELECT * FROM posts
+WHERE created_at < '2023-06-01'
+ORDER BY created_at DESC
+LIMIT 20;
+```

data/files/sql/mysql/middle/regex_search.md

@@ -0,0 +1,12 @@
+## 🧵 Using REGEXP for Pattern Matching
+`REGEXP` (or `RLIKE`) provides powerful pattern matching beyond simple `LIKE`. It supports character classes, quantifiers, and anchors. Remember that regex queries can be slow on large tables—combine with indexed columns when possible.
+
+```sql
+-- Names starting with A or B
+SELECT name FROM products
+WHERE name REGEXP '^[AB]';
+
+-- Email validation example
+SELECT email FROM users
+WHERE email REGEXP '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$';
+```

data/files/sql/mysql/middle/user_variables.md

@@ -0,0 +1,13 @@
+## 🎯 Using User-Defined Variables for Row-by-Row Computations
+User variables let you store values and carry state across rows in a single query. They’re helpful for running totals or custom ranking before window functions were available. Initialize them in the SELECT or a subquery.
+
+```sql
+SET @running_total = 0;
+
+SELECT
+  order_date,
+  amount,
+  (@running_total := @running_total + amount) AS cumulative_amount
+FROM orders
+ORDER BY order_date;
+```

data/files/sql/mysql/middle/window_functions.md

@@ -0,0 +1,10 @@
+## 🪟 Leveraging Window Functions for Advanced Aggregation
+Window functions let you compute totals, ranks, and moving averages without grouping your result set. They maintain row-level details while adding aggregated columns. Use `OVER()` with `PARTITION BY` and `ORDER BY` to scope calculations.
+
+```sql
+SELECT
+  user_id,
+  order_date,
+  SUM(amount) OVER (PARTITION BY user_id ORDER BY order_date ROWS BETWEEN 4 PRECEDING AND CURRENT ROW) AS rolling_sum
+FROM orders;
+```

data/files/sql/postgresql/advanced/declarative_partitioning_range.md

@@ -0,0 +1,16 @@
+## 📂 Declarative Range Partitioning for Large Tables
+Partition large fact tables by range (e.g., date or numeric ranges) to improve query performance and management. PostgreSQL’s declarative partitioning automatically routes inserts to the correct partition and prunes irrelevant partitions at query time. Create child tables with check constraints for each range.
+
+```sql
+CREATE TABLE events (
+  id SERIAL PRIMARY KEY,
+  event_time TIMESTAMP NOT NULL,
+  payload JSONB
+) PARTITION BY RANGE (event_time);
+
+CREATE TABLE events_2023_q1 PARTITION OF events
+  FOR VALUES FROM ('2023-01-01') TO ('2023-04-01');
+
+CREATE TABLE events_2023_q2 PARTITION OF events
+  FOR VALUES FROM ('2023-04-01') TO ('2023-07-01');
+```