Datasets:
Tasks:
Text Generation
Modalities:
Text
Formats:
parquet
Languages:
English
Size:
10K - 100K
License:
id large_stringlengths 18 18 | instruction large_stringlengths 114 139 | schema large_stringclasses 4
values | sql_query large_stringlengths 123 180 | execution_result large_stringlengths 2 1.62k | input large_stringlengths 317 503 | output large_stringlengths 181 2.25k |
|---|---|---|---|---|---|---|
sql_synth_00000001 | Find all completed transactions in the 'Subscription' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000002 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 665.78. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 665.78 ORDER BY total_revenue DESC; | [{"category": "Hardware", "total_revenue": 1830.48}, {"category": "License", "total_revenue": 1492.45}, {"category": "Service", "total_revenue": 1146.19}, {"category": "Subscription", "total_revenue": 711.69}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 665... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 665.78 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Hardware",
"total_revenue": 1830.48
},
{
"category": "License",
"t... |
sql_synth_00000003 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1009", "quantity": 13, "unit_price": 30.01, "restock_cost": 2610.8700000000003}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1009",
"quantity": 13,
"unit_price": 30.01,
"restock_cost": 2610.8700000000003... |
sql_synth_00000004 | Retrieve the username and reputation of all active users in the 'Enterprise' tier with a reputation score greater than 249. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Enterprise' AND reputation > 249 ORDER BY reputation DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Enterprise' tier with a reputation score greater than 2... | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Enterprise' AND reputation > 249 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000005 | Find all completed transactions in the 'Hardware' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Hardware' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Hardware' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000006 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 415.00. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 415.00 ORDER BY total_revenue DESC; | [{"category": "Compute", "total_revenue": 1861.3400000000001}, {"category": "Hardware", "total_revenue": 1575.83}, {"category": "Subscription", "total_revenue": 1387.79}, {"category": "Service", "total_revenue": 1064.47}, {"category": "License", "total_revenue": 475.04999999999995}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 415... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 415.00 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Compute",
"total_revenue": 1861.3400000000001
},
{
"category": "Hardwa... |
sql_synth_00000007 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1012", "quantity": 11, "unit_price": 45.77, "restock_cost": 4073.53}, {"sku": "SKU-1016", "quantity": 15, "unit_price": 45.23, "restock_cost": 3844.5499999999997}, {"sku": "SKU-1004", "quantity": 3, "unit_price": 32.92, "restock_cost": 3193.2400000000002}, {"sku": "SKU-1008", "quantity": 7, "unit_price": ... | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1012",
"quantity": 11,
"unit_price": 45.77,
"restock_cost": 4073.53
},
{
... |
sql_synth_00000008 | Retrieve the username and reputation of all active users in the 'Platinum' tier with a reputation score greater than 339. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Platinum' AND reputation > 339 ORDER BY reputation DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Platinum' tier with a reputation score greater than 339... | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Platinum' AND reputation > 339 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000009 | Find all completed transactions in the 'Compute' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Compute' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Compute' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000010 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 175.40. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 175.40 ORDER BY total_revenue DESC; | [{"category": "License", "total_revenue": 1758.6}, {"category": "Subscription", "total_revenue": 1334.54}, {"category": "Compute", "total_revenue": 1315.76}, {"category": "Hardware", "total_revenue": 923.38}, {"category": "Service", "total_revenue": 825.18}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 175... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 175.40 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "License",
"total_revenue": 1758.6
},
{
"category": "Subscription",
... |
sql_synth_00000011 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1010", "quantity": 18, "unit_price": 41.5, "restock_cost": 3403.0}, {"sku": "SKU-1005", "quantity": 9, "unit_price": 18.83, "restock_cost": 1713.5299999999997}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1010",
"quantity": 18,
"unit_price": 41.5,
"restock_cost": 3403.0
},
{
... |
sql_synth_00000012 | Retrieve the username and reputation of all active users in the 'Gold' tier with a reputation score greater than 334. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Gold' AND reputation > 334 ORDER BY reputation DESC; | [{"username": "user_005", "reputation": 548}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Gold' tier with a reputation score greater than 334. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Gold' AND reputation > 334 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_005",
"reputation": 548
}
]
``` |
sql_synth_00000013 | Find all completed transactions in the 'License' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'License' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'License' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000014 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 532.38. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 532.38 ORDER BY total_revenue DESC; | [] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 532... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 532.38 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000015 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1013", "quantity": 10, "unit_price": 49.74, "restock_cost": 4476.6}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1013",
"quantity": 10,
"unit_price": 49.74,
"restock_cost": 4476.6
}
]
``` |
sql_synth_00000016 | Retrieve the username and reputation of all active users in the 'Silver' tier with a reputation score greater than 237. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Silver' AND reputation > 237 ORDER BY reputation DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Silver' tier with a reputation score greater than 237. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Silver' AND reputation > 237 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000017 | Find all completed transactions in the 'Service' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Service' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Service' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000018 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 697.72. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 697.72 ORDER BY total_revenue DESC; | [{"category": "Subscription", "total_revenue": 1785.48}, {"category": "Compute", "total_revenue": 1412.98}, {"category": "Service", "total_revenue": 1163.95}, {"category": "License", "total_revenue": 1126.76}, {"category": "Hardware", "total_revenue": 922.24}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 697... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 697.72 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Subscription",
"total_revenue": 1785.48
},
{
"category": "Compute",
... |
sql_synth_00000019 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1019", "quantity": 0, "unit_price": 42.0, "restock_cost": 4200.0}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1019",
"quantity": 0,
"unit_price": 42.0,
"restock_cost": 4200.0
}
]
``` |
sql_synth_00000020 | Retrieve the username and reputation of all active users in the 'Bronze' tier with a reputation score greater than 114. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Bronze' AND reputation > 114 ORDER BY reputation DESC; | [{"username": "user_005", "reputation": 544}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Bronze' tier with a reputation score greater than 114. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Bronze' AND reputation > 114 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_005",
"reputation": 544
}
]
``` |
sql_synth_00000021 | Find all completed transactions in the 'Subscription' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000022 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 598.10. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 598.10 ORDER BY total_revenue DESC; | [{"category": "Service", "total_revenue": 1570.94}, {"category": "Subscription", "total_revenue": 1555.52}, {"category": "License", "total_revenue": 1509.63}, {"category": "Hardware", "total_revenue": 1440.3500000000001}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 598... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 598.10 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Service",
"total_revenue": 1570.94
},
{
"category": "Subscription",
... |
sql_synth_00000023 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1006", "quantity": 14, "unit_price": 7.0, "restock_cost": 602.0}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1006",
"quantity": 14,
"unit_price": 7.0,
"restock_cost": 602.0
}
]
``` |
sql_synth_00000024 | Retrieve the username and reputation of all active users in the 'Enterprise' tier with a reputation score greater than 260. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Enterprise' AND reputation > 260 ORDER BY reputation DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Enterprise' tier with a reputation score greater than 2... | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Enterprise' AND reputation > 260 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000025 | Find all completed transactions in the 'Hardware' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Hardware' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Hardware' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000026 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 277.72. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 277.72 ORDER BY total_revenue DESC; | [{"category": "Service", "total_revenue": 1689.91}, {"category": "Compute", "total_revenue": 1475.23}, {"category": "Subscription", "total_revenue": 1254.42}, {"category": "License", "total_revenue": 936.13}, {"category": "Hardware", "total_revenue": 844.4200000000001}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 277... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 277.72 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Service",
"total_revenue": 1689.91
},
{
"category": "Compute",
"to... |
sql_synth_00000027 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1001", "quantity": 13, "unit_price": 30.01, "restock_cost": 2610.8700000000003}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1001",
"quantity": 13,
"unit_price": 30.01,
"restock_cost": 2610.8700000000003... |
sql_synth_00000028 | Retrieve the username and reputation of all active users in the 'Platinum' tier with a reputation score greater than 343. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Platinum' AND reputation > 343 ORDER BY reputation DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Platinum' tier with a reputation score greater than 343... | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Platinum' AND reputation > 343 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000029 | Find all completed transactions in the 'Compute' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Compute' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Compute' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000030 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 321.44. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 321.44 ORDER BY total_revenue DESC; | [{"category": "License", "total_revenue": 2128.3199999999997}, {"category": "Subscription", "total_revenue": 2005.49}, {"category": "Hardware", "total_revenue": 918.01}, {"category": "Compute", "total_revenue": 605.24}, {"category": "Service", "total_revenue": 516.87}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 321... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 321.44 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "License",
"total_revenue": 2128.3199999999997
},
{
"category": "Subscr... |
sql_synth_00000031 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1017", "quantity": 11, "unit_price": 16.2, "restock_cost": 1441.8}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1017",
"quantity": 11,
"unit_price": 16.2,
"restock_cost": 1441.8
}
]
``` |
sql_synth_00000032 | Retrieve the username and reputation of all active users in the 'Gold' tier with a reputation score greater than 329. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Gold' AND reputation > 329 ORDER BY reputation DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Gold' tier with a reputation score greater than 329. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Gold' AND reputation > 329 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000033 | Find all completed transactions in the 'License' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'License' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'License' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000034 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 622.46. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 622.46 ORDER BY total_revenue DESC; | [{"category": "Service", "total_revenue": 1935.29}, {"category": "License", "total_revenue": 1376.12}, {"category": "Hardware", "total_revenue": 1228.23}, {"category": "Compute", "total_revenue": 1105.9099999999999}, {"category": "Subscription", "total_revenue": 869.53}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 622... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 622.46 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Service",
"total_revenue": 1935.29
},
{
"category": "License",
"to... |
sql_synth_00000035 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1004", "quantity": 19, "unit_price": 14.14, "restock_cost": 1145.3400000000001}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1004",
"quantity": 19,
"unit_price": 14.14,
"restock_cost": 1145.3400000000001... |
sql_synth_00000036 | Retrieve the username and reputation of all active users in the 'Silver' tier with a reputation score greater than 224. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Silver' AND reputation > 224 ORDER BY reputation DESC; | [{"username": "user_005", "reputation": 532}, {"username": "user_010", "reputation": 300}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Silver' tier with a reputation score greater than 224. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Silver' AND reputation > 224 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_005",
"reputation": 532
},
{
"username": "user_010",
"reputation": 300
}
]
``` |
sql_synth_00000037 | Find all completed transactions in the 'Service' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Service' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Service' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000038 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 691.88. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 691.88 ORDER BY total_revenue DESC; | [{"category": "Compute", "total_revenue": 1694.04}, {"category": "Subscription", "total_revenue": 1506.38}, {"category": "Service", "total_revenue": 1271.31}, {"category": "License", "total_revenue": 794.24}, {"category": "Hardware", "total_revenue": 771.31}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 691... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 691.88 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Compute",
"total_revenue": 1694.04
},
{
"category": "Subscription",
... |
sql_synth_00000039 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1005", "quantity": 10, "unit_price": 49.74, "restock_cost": 4476.6}, {"sku": "SKU-1010", "quantity": 20, "unit_price": 48.96, "restock_cost": 3916.8}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1005",
"quantity": 10,
"unit_price": 49.74,
"restock_cost": 4476.6
},
{
... |
sql_synth_00000040 | Retrieve the username and reputation of all active users in the 'Bronze' tier with a reputation score greater than 129. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Bronze' AND reputation > 129 ORDER BY reputation DESC; | [{"username": "user_010", "reputation": 325}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Bronze' tier with a reputation score greater than 129. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Bronze' AND reputation > 129 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_010",
"reputation": 325
}
]
``` |
sql_synth_00000041 | Find all completed transactions in the 'Subscription' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000042 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 498.96. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 498.96 ORDER BY total_revenue DESC; | [{"category": "Hardware", "total_revenue": 1145.46}, {"category": "License", "total_revenue": 987.73}, {"category": "Subscription", "total_revenue": 839.81}, {"category": "Compute", "total_revenue": 733.45}, {"category": "Service", "total_revenue": 622.9}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 498... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 498.96 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Hardware",
"total_revenue": 1145.46
},
{
"category": "License",
"t... |
sql_synth_00000043 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1011", "quantity": 14, "unit_price": 49.55, "restock_cost": 4261.3}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1011",
"quantity": 14,
"unit_price": 49.55,
"restock_cost": 4261.3
}
]
``` |
sql_synth_00000044 | Retrieve the username and reputation of all active users in the 'Enterprise' tier with a reputation score greater than 271. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Enterprise' AND reputation > 271 ORDER BY reputation DESC; | [{"username": "user_005", "reputation": 524}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Enterprise' tier with a reputation score greater than 2... | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Enterprise' AND reputation > 271 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_005",
"reputation": 524
}
]
``` |
sql_synth_00000045 | Find all completed transactions in the 'Hardware' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Hardware' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Hardware' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000046 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 129.20. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 129.20 ORDER BY total_revenue DESC; | [{"category": "Compute", "total_revenue": 1687.95}, {"category": "Service", "total_revenue": 1661.91}, {"category": "Subscription", "total_revenue": 1244.71}, {"category": "License", "total_revenue": 968.49}, {"category": "Hardware", "total_revenue": 871.61}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 129... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 129.20 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Compute",
"total_revenue": 1687.95
},
{
"category": "Service",
"to... |
sql_synth_00000047 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1013", "quantity": 0, "unit_price": 13.29, "restock_cost": 1329.0}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1013",
"quantity": 0,
"unit_price": 13.29,
"restock_cost": 1329.0
}
]
``` |
sql_synth_00000048 | Retrieve the username and reputation of all active users in the 'Platinum' tier with a reputation score greater than 346. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Platinum' AND reputation > 346 ORDER BY reputation DESC; | [{"username": "user_010", "reputation": 372}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Platinum' tier with a reputation score greater than 346... | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Platinum' AND reputation > 346 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_010",
"reputation": 372
}
]
``` |
sql_synth_00000049 | Find all completed transactions in the 'Compute' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Compute' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Compute' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000050 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 453.50. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 453.50 ORDER BY total_revenue DESC; | [{"category": "Subscription", "total_revenue": 2005.49}, {"category": "Hardware", "total_revenue": 1630.87}, {"category": "Compute", "total_revenue": 1310.3200000000002}, {"category": "License", "total_revenue": 754.41}, {"category": "Service", "total_revenue": 546.06}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 453... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 453.50 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Subscription",
"total_revenue": 2005.49
},
{
"category": "Hardware",
... |
sql_synth_00000051 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1006", "quantity": 8, "unit_price": 40.75, "restock_cost": 3749.0}, {"sku": "SKU-1012", "quantity": 17, "unit_price": 16.8, "restock_cost": 1394.4}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1006",
"quantity": 8,
"unit_price": 40.75,
"restock_cost": 3749.0
},
{
... |
sql_synth_00000052 | Retrieve the username and reputation of all active users in the 'Gold' tier with a reputation score greater than 323. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Gold' AND reputation > 323 ORDER BY reputation DESC; | [{"username": "user_010", "reputation": 394}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Gold' tier with a reputation score greater than 323. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Gold' AND reputation > 323 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_010",
"reputation": 394
}
]
``` |
sql_synth_00000053 | Find all completed transactions in the 'License' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'License' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'License' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000054 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 679.52. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 679.52 ORDER BY total_revenue DESC; | [{"category": "Hardware", "total_revenue": 1800.73}, {"category": "Service", "total_revenue": 1766.51}, {"category": "Compute", "total_revenue": 1238.5500000000002}, {"category": "Subscription", "total_revenue": 1091.96}, {"category": "License", "total_revenue": 819.63}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 679... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 679.52 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Hardware",
"total_revenue": 1800.73
},
{
"category": "Service",
"t... |
sql_synth_00000055 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1002", "quantity": 18, "unit_price": 41.5, "restock_cost": 3403.0}, {"sku": "SKU-1001", "quantity": 9, "unit_price": 18.83, "restock_cost": 1713.5299999999997}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1002",
"quantity": 18,
"unit_price": 41.5,
"restock_cost": 3403.0
},
{
... |
sql_synth_00000056 | Retrieve the username and reputation of all active users in the 'Silver' tier with a reputation score greater than 212. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Silver' AND reputation > 212 ORDER BY reputation DESC; | [{"username": "user_005", "reputation": 248}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Silver' tier with a reputation score greater than 212. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Silver' AND reputation > 212 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_005",
"reputation": 248
}
]
``` |
sql_synth_00000057 | Find all completed transactions in the 'Service' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Service' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Service' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000058 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 648.66. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 648.66 ORDER BY total_revenue DESC; | [{"category": "Compute", "total_revenue": 2333.26}, {"category": "Subscription", "total_revenue": 2093.42}, {"category": "Service", "total_revenue": 1100.46}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 648... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 648.66 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Compute",
"total_revenue": 2333.26
},
{
"category": "Subscription",
... |
sql_synth_00000059 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1008", "quantity": 2, "unit_price": 49.92, "restock_cost": 4892.16}, {"sku": "SKU-1016", "quantity": 4, "unit_price": 49.67, "restock_cost": 4768.32}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1008",
"quantity": 2,
"unit_price": 49.92,
"restock_cost": 4892.16
},
{
... |
sql_synth_00000060 | Retrieve the username and reputation of all active users in the 'Bronze' tier with a reputation score greater than 143. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Bronze' AND reputation > 143 ORDER BY reputation DESC; | [{"username": "user_005", "reputation": 502}, {"username": "user_010", "reputation": 434}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Bronze' tier with a reputation score greater than 143. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Bronze' AND reputation > 143 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_005",
"reputation": 502
},
{
"username": "user_010",
"reputation": 434
}
]
``` |
sql_synth_00000061 | Find all completed transactions in the 'Subscription' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000062 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 374.62. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 374.62 ORDER BY total_revenue DESC; | [{"category": "Hardware", "total_revenue": 1680.91}, {"category": "License", "total_revenue": 1529.89}, {"category": "Compute", "total_revenue": 1132.86}, {"category": "Subscription", "total_revenue": 1005.26}, {"category": "Service", "total_revenue": 762.71}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 374... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 374.62 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Hardware",
"total_revenue": 1680.91
},
{
"category": "License",
"t... |
sql_synth_00000063 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1015", "quantity": 12, "unit_price": 49.09, "restock_cost": 4319.92}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1015",
"quantity": 12,
"unit_price": 49.09,
"restock_cost": 4319.92
}
]
``` |
sql_synth_00000064 | Retrieve the username and reputation of all active users in the 'Enterprise' tier with a reputation score greater than 281. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Enterprise' AND reputation > 281 ORDER BY reputation DESC; | [{"username": "user_010", "reputation": 452}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Enterprise' tier with a reputation score greater than 2... | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Enterprise' AND reputation > 281 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_010",
"reputation": 452
}
]
``` |
sql_synth_00000065 | Find all completed transactions in the 'Hardware' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Hardware' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Hardware' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000066 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 221.14. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 221.14 ORDER BY total_revenue DESC; | [{"category": "Compute", "total_revenue": 1920.57}, {"category": "Service", "total_revenue": 1837.12}, {"category": "Subscription", "total_revenue": 1133.78}, {"category": "Hardware", "total_revenue": 1015.3399999999999}, {"category": "License", "total_revenue": 607.96}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 221... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 221.14 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Compute",
"total_revenue": 1920.57
},
{
"category": "Service",
"to... |
sql_synth_00000067 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1017", "quantity": 5, "unit_price": 50.0, "restock_cost": 4750.0}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1017",
"quantity": 5,
"unit_price": 50.0,
"restock_cost": 4750.0
}
]
``` |
sql_synth_00000068 | Retrieve the username and reputation of all active users in the 'Platinum' tier with a reputation score greater than 348. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Platinum' AND reputation > 348 ORDER BY reputation DESC; | [{"username": "user_005", "reputation": 489}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Platinum' tier with a reputation score greater than 348... | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Platinum' AND reputation > 348 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_005",
"reputation": 489
}
]
``` |
sql_synth_00000069 | Find all completed transactions in the 'Compute' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Compute' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Compute' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000070 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 563.22. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 563.22 ORDER BY total_revenue DESC; | [{"category": "License", "total_revenue": 1591.3000000000002}, {"category": "Subscription", "total_revenue": 1399.6799999999998}, {"category": "Compute", "total_revenue": 1221.62}, {"category": "Service", "total_revenue": 1090.82}, {"category": "Hardware", "total_revenue": 942.46}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 563... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 563.22 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "License",
"total_revenue": 1591.3000000000002
},
{
"category": "Subscr... |
sql_synth_00000071 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1009", "quantity": 4, "unit_price": 34.55, "restock_cost": 3316.7999999999997}, {"sku": "SKU-1018", "quantity": 8, "unit_price": 11.2, "restock_cost": 1030.3999999999999}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1009",
"quantity": 4,
"unit_price": 34.55,
"restock_cost": 3316.7999999999997
... |
sql_synth_00000072 | Retrieve the username and reputation of all active users in the 'Gold' tier with a reputation score greater than 316. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Gold' AND reputation > 316 ORDER BY reputation DESC; | [{"username": "user_010", "reputation": 484}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Gold' tier with a reputation score greater than 316. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Gold' AND reputation > 316 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_010",
"reputation": 484
}
]
``` |
sql_synth_00000073 | Find all completed transactions in the 'License' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'License' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'License' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000074 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 699.96. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 699.96 ORDER BY total_revenue DESC; | [{"category": "Service", "total_revenue": 1686.16}, {"category": "Hardware", "total_revenue": 1683.8700000000001}, {"category": "Compute", "total_revenue": 1249.94}, {"category": "License", "total_revenue": 1138.35}, {"category": "Subscription", "total_revenue": 874.23}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 699... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 699.96 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Service",
"total_revenue": 1686.16
},
{
"category": "Hardware",
"t... |
sql_synth_00000075 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1010", "quantity": 2, "unit_price": 47.86, "restock_cost": 4690.28}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1010",
"quantity": 2,
"unit_price": 47.86,
"restock_cost": 4690.28
}
]
``` |
sql_synth_00000076 | Retrieve the username and reputation of all active users in the 'Silver' tier with a reputation score greater than 198. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Silver' AND reputation > 198 ORDER BY reputation DESC; | [{"username": "user_010", "reputation": 497}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Silver' tier with a reputation score greater than 198. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Silver' AND reputation > 198 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_010",
"reputation": 497
}
]
``` |
sql_synth_00000077 | Find all completed transactions in the 'Service' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Service' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Service' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000078 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 570.78. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 570.78 ORDER BY total_revenue DESC; | [{"category": "Compute", "total_revenue": 2260.73}, {"category": "License", "total_revenue": 1559.52}, {"category": "Hardware", "total_revenue": 974.02}, {"category": "Service", "total_revenue": 881.09}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 570... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 570.78 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Compute",
"total_revenue": 2260.73
},
{
"category": "License",
"to... |
sql_synth_00000079 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1013", "quantity": 9, "unit_price": 44.94, "restock_cost": 4089.54}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1013",
"quantity": 9,
"unit_price": 44.94,
"restock_cost": 4089.54
}
]
``` |
sql_synth_00000080 | Retrieve the username and reputation of all active users in the 'Bronze' tier with a reputation score greater than 157. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Bronze' AND reputation > 157 ORDER BY reputation DESC; | [{"username": "user_005", "reputation": 325}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Bronze' tier with a reputation score greater than 157. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Bronze' AND reputation > 157 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_005",
"reputation": 325
}
]
``` |
sql_synth_00000081 | Find all completed transactions in the 'Subscription' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000082 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 232.94. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 232.94 ORDER BY total_revenue DESC; | [{"category": "Hardware", "total_revenue": 1821.7800000000002}, {"category": "License", "total_revenue": 1691.54}, {"category": "Service", "total_revenue": 1111.8}, {"category": "Compute", "total_revenue": 1090.08}, {"category": "Subscription", "total_revenue": 975.0899999999999}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 232... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 232.94 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Hardware",
"total_revenue": 1821.7800000000002
},
{
"category": "Licen... |
sql_synth_00000083 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1001", "quantity": 5, "unit_price": 47.17, "restock_cost": 4481.150000000001}, {"sku": "SKU-1002", "quantity": 10, "unit_price": 39.02, "restock_cost": 3511.8}, {"sku": "SKU-1003", "quantity": 16, "unit_price": 26.59, "restock_cost": 2233.56}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1001",
"quantity": 5,
"unit_price": 47.17,
"restock_cost": 4481.150000000001
... |
sql_synth_00000084 | Retrieve the username and reputation of all active users in the 'Enterprise' tier with a reputation score greater than 291. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Enterprise' AND reputation > 291 ORDER BY reputation DESC; | [{"username": "user_010", "reputation": 520}, {"username": "user_005", "reputation": 458}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Enterprise' tier with a reputation score greater than 2... | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Enterprise' AND reputation > 291 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_010",
"reputation": 520
},
{
"username": "user_005",
"reputation": 458
}
]
``` |
sql_synth_00000085 | Find all completed transactions in the 'Hardware' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Hardware' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Hardware' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000086 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 363.84. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 363.84 ORDER BY total_revenue DESC; | [{"category": "Service", "total_revenue": 2391.08}, {"category": "Compute", "total_revenue": 1704.6599999999999}, {"category": "Hardware", "total_revenue": 1460.67}, {"category": "License", "total_revenue": 798.28}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 363... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 363.84 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Service",
"total_revenue": 2391.08
},
{
"category": "Compute",
"to... |
sql_synth_00000087 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1015", "quantity": 4, "unit_price": 38.61, "restock_cost": 3706.56}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1015",
"quantity": 4,
"unit_price": 38.61,
"restock_cost": 3706.56
}
]
``` |
sql_synth_00000088 | Retrieve the username and reputation of all active users in the 'Platinum' tier with a reputation score greater than 349. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Platinum' AND reputation > 349 ORDER BY reputation DESC; | [{"username": "user_010", "reputation": 529}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Platinum' tier with a reputation score greater than 349... | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Platinum' AND reputation > 349 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_010",
"reputation": 529
}
]
``` |
sql_synth_00000089 | Find all completed transactions in the 'Compute' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Compute' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Compute' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000090 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 643.68. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 643.68 ORDER BY total_revenue DESC; | [{"category": "Subscription", "total_revenue": 1774.0099999999998}, {"category": "License", "total_revenue": 1383.5700000000002}, {"category": "Service", "total_revenue": 1236.76}, {"category": "Hardware", "total_revenue": 943.75}, {"category": "Compute", "total_revenue": 905.09}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 643... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 643.68 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Subscription",
"total_revenue": 1774.0099999999998
},
{
"category": "L... |
sql_synth_00000091 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1018", "quantity": 9, "unit_price": 32.73, "restock_cost": 2978.43}, {"sku": "SKU-1011", "quantity": 20, "unit_price": 6.38, "restock_cost": 510.4}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1018",
"quantity": 9,
"unit_price": 32.73,
"restock_cost": 2978.43
},
{
... |
sql_synth_00000092 | Retrieve the username and reputation of all active users in the 'Gold' tier with a reputation score greater than 308. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Gold' AND reputation > 308 ORDER BY reputation DESC; | [{"username": "user_005", "reputation": 441}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Gold' tier with a reputation score greater than 308. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Gold' AND reputation > 308 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_005",
"reputation": 441
}
]
``` |
sql_synth_00000093 | Find all completed transactions in the 'License' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'License' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'License' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000094 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 682.52. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 682.52 ORDER BY total_revenue DESC; | [{"category": "Service", "total_revenue": 2264.68}, {"category": "Hardware", "total_revenue": 1703.65}, {"category": "Compute", "total_revenue": 1408.31}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 682... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 682.52 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Service",
"total_revenue": 2264.68
},
{
"category": "Hardware",
"t... |
sql_synth_00000095 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1019", "quantity": 3, "unit_price": 49.71, "restock_cost": 4821.87}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1019",
"quantity": 3,
"unit_price": 49.71,
"restock_cost": 4821.87
}
]
``` |
sql_synth_00000096 | Retrieve the username and reputation of all active users in the 'Silver' tier with a reputation score greater than 185. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Silver' AND reputation > 185 ORDER BY reputation DESC; | [{"username": "user_010", "reputation": 542}, {"username": "user_005", "reputation": 372}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Silver' tier with a reputation score greater than 185. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Silver' AND reputation > 185 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_010",
"reputation": 542
},
{
"username": "user_005",
"reputation": 372
}
]
``` |
sql_synth_00000097 | Find all completed transactions in the 'Service' category, returning the username, transaction amount, and status. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
c... | SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Service' AND t.status = 'Completed' ORDER BY t.amount DESC; | [] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
... | ```sql
SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Service' AND t.status = 'Completed' ORDER BY t.amount DESC;
```
**Verified Execution Output:**
```json
[]
``` |
sql_synth_00000098 | Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 463.16. | CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
); | SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 463.16 ORDER BY total_revenue DESC; | [{"category": "Subscription", "total_revenue": 1698.39}, {"category": "Compute", "total_revenue": 1546.8700000000001}, {"category": "Service", "total_revenue": 1403.21}, {"category": "Hardware", "total_revenue": 1302.59}, {"category": "License", "total_revenue": 1160.6999999999998}] | Schema:
CREATE TABLE transactions (
tx_id INTEGER PRIMARY KEY,
user_id INTEGER,
amount REAL,
category TEXT,
status TEXT
);
Task:
Calculate the total amount spent per category for all non-failed transactions where the total category revenue exceeds 463... | ```sql
SELECT category, SUM(amount) AS total_revenue FROM transactions WHERE status != 'Failed' GROUP BY category HAVING SUM(amount) > 463.16 ORDER BY total_revenue DESC;
```
**Verified Execution Output:**
```json
[
{
"category": "Subscription",
"total_revenue": 1698.39
},
{
"category": "Compute",
... |
sql_synth_00000099 | Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restocking cost to reach 100 units. | CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
); | SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC; | [{"sku": "SKU-1016", "quantity": 16, "unit_price": 27.14, "restock_cost": 2279.76}] | Schema:
CREATE TABLE inventory (
item_id INTEGER PRIMARY KEY,
sku TEXT,
quantity INTEGER,
unit_price REAL,
reorder_level INTEGER
);
Task:
Identify inventory items where the quantity is at or below the reorder level, calculating the estimated restockin... | ```sql
SELECT sku, quantity, unit_price, ((100 - quantity) * unit_price) AS restock_cost FROM inventory WHERE quantity <= reorder_level ORDER BY restock_cost DESC;
```
**Verified Execution Output:**
```json
[
{
"sku": "SKU-1016",
"quantity": 16,
"unit_price": 27.14,
"restock_cost": 2279.76
}
]
``` |
sql_synth_00000100 | Retrieve the username and reputation of all active users in the 'Bronze' tier with a reputation score greater than 171. | CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
); | SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Bronze' AND reputation > 171 ORDER BY reputation DESC; | [{"username": "user_010", "reputation": 546}] | Schema:
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
username TEXT,
tier TEXT,
reputation INTEGER,
is_active INTEGER
);
Task:
Retrieve the username and reputation of all active users in the 'Bronze' tier with a reputation score greater than 171. | ```sql
SELECT username, reputation FROM users WHERE is_active = 1 AND tier = 'Bronze' AND reputation > 171 ORDER BY reputation DESC;
```
**Verified Execution Output:**
```json
[
{
"username": "user_010",
"reputation": 546
}
]
``` |
End of preview. Expand in Data Studio
🗄️ Deterministic Text-to-SQL & Ground-Truth Execution Dataset
⚡ Full Production Release Available: Looking for commercial licensing or larger training volume?
📦 Download the Full 100,000 Verified SQL Dataset (.Parquet + .JSONL) with Commercial Rights →
A high-density, 100% verified synthetic dataset designed for fine-tuning LLMs on Text-to-SQL generation, schema-to-query reasoning, relational JOINs, aggregations, and ground-truth tabular execution.
Every row in this dataset has been compiled and executed against an isolated in-memory SQLite relational sandbox to guarantee zero syntax hallucinations and exact tabular outputs.
Dataset Overview
- Rows (Free Preview): 10,000 verified query/execution pairs
- Full Production Corpus: 100,000 samples (Dual Parquet + JSONL)
- Format: Apache Parquet (Snappy Compressed) + JSONL
- Zero Hallucination: 100% of queries are validated against live in-memory SQLite schemas.
- Relational Archetypes: Multi-table schemas (Users, Transactions, Inventory) covering filters, multi-table
INNER JOINoperations,GROUP BY ... HAVINGaggregations, and computed column transforms.
Commercial vs. Research Access
| Feature | 10k Hugging Face Sample | 100k Full Production Corpus |
|---|---|---|
| Sample Count | 10,000 rows | 100,000 rows |
| Formats Included | .parquet + .jsonl |
.parquet + .jsonl |
| Query Complexity | Single-table & basic JOINs | 4 Exhaustive Relational Archetypes |
| License | CC-BY-NC 4.0 (Non-Commercial) | Full Commercial License |
| Access | Free Download | Purchase ($24) → |
Schema Structure
| Column | Type | Description |
|---|---|---|
id |
string | Unique deterministic sample identifier |
instruction |
string | Natural language query prompt |
schema |
string | Raw SQLite DDL table definitions provided as context |
sql_query |
string | Executable SQL query solution |
execution_result |
string (JSON) | Exact ground-truth tabular output from SQLite execution |
input |
string | Pre-formatted context block (DDL Schema + Natural Language Task) |
output |
string | Markdown-formatted SQL solution + ground-truth execution block |
Sample Record
{
"id": "sql_synth_00000001",
"instruction": "Find all completed transactions in the 'Subscription' category, returning the username, transaction amount, and status.",
"schema": "CREATE TABLE users (...);\nCREATE TABLE transactions (...);",
"sql_query": "SELECT u.username, t.amount, t.status FROM transactions t JOIN users u ON t.user_id = u.user_id WHERE t.category = 'Subscription' AND t.status = 'Completed' ORDER BY t.amount DESC;",
"execution_result": "[{\"username\": \"user_001\", \"amount\": 420.5, \"status\": \"Completed\"}]"
}
Quickstart
Python
from datasets import load_dataset
dataset = load_dataset("adolessence101-ally/synthetic-sql-groundtruth-10k")
print(dataset["train"][0])
- Downloads last month
- -