AI SQL query generator (text to SQL)

Some of these runs are missing or out of date (Claude Fable 5.1 has 0 of 5 runs scored), so this page stays out of search until they're all in.

Run on September 28, 2026: 5 inputs on 14 models, each with this tool's own instructions.

Write one SQL query for this, in a ```sql code block, then a few lines on how it works. Use only these tables and columns. Write it for SQLite.

---
Tables (SQLite):
CREATE TABLE customers (id INTEGER PRIMARY KEY, name TEXT NOT NULL, country TEXT NOT NULL, signed_up TEXT NOT NULL);
CREATE TABLE products (id INTEGER PRIMARY KEY, name TEXT NOT NULL, category TEXT NOT NULL, price_cents INTEGER NOT NULL);
CREATE TABLE orders (id INTEGER PRIMARY KEY, customer_id INTEGER NOT NULL REFERENCES customers(id), ordered_on TEXT NOT NULL, status TEXT NOT NULL);
CREATE TABLE order_items (order_id INTEGER NOT NULL REFERENCES orders(id), product_id INTEGER NOT NULL REFERENCES products(id), quantity INTEGER NOT NULL);

Question: the customers whose second order came within 60 days of their first, ignoring cancelled orders and ordering each customer's orders by date. Return only their names, sorted by name.

```sql
SELECT c.name
FROM (
  SELECT customer_id,
         ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY ordered_on, id) AS rn
  FROM orders
  WHERE status <> 'cancelled'
) ranked
JOIN (
  SELECT customer_id,
         MIN(ordered_on) AS first_order,
         MAX(ordered_on) AS second_order
  FROM (
    SELECT customer_id, ordered_on,
           ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY ordered_on, id) AS rn
    FROM orders
    WHERE status <> 'cancelled'
  ) r
  WHERE rn <= 2
  GROUP BY customer_id
  HAVING COUNT(*) = 2
) s ON s.customer_id = ranked.customer_id
JOIN customers c ON c.id = ranked.customer_id
WHERE CAST(julianday(s.second_order) - julianday(s.first_order) AS INTEGER) <= 60
GROUP BY c.id, c.name
ORDER BY c.name;
```

- Cancels are filtered out first, and orders are numbered per customer by date (with `id` as a tie-breaker so duplicate dates get a stable order).
- The second CTE keeps only customers with at least two non-cancelled orders (`HAVING COUNT(*) = 2` after taking rows 1–2) and gets their first and second order dates.
- `julianday()` converts the date strings so the gap can be compared to 60 days; `GROUP BY c.id` prevents duplicate names if two customers share a name, and results are sorted by name.
- Note: since `signed_up`, `products` etc. aren't needed, they're untouched; adjust `<= 60` to `< 60` if "within" should be exclusive of exactly 60.

```sql
WITH ranked_orders AS (
  SELECT
    customer_id,
    ordered_on,
    ROW_NUMBER() OVER (
      PARTITION BY customer_id
      ORDER BY ordered_on, id
    ) AS order_rank
  FROM orders
  WHERE status <> 'cancelled'
)
SELECT c.name
FROM customers AS c
JOIN ranked_orders AS first_order
  ON first_order.customer_id = c.id
 AND first_order.order_rank = 1
JOIN ranked_orders AS second_order
  ON second_order.customer_id = c.id
 AND second_order.order_rank = 2
WHERE julianday(second_order.ordered_on) - julianday(first_order.ordered_on) <= 60
ORDER BY c.name;
```

The query ranks each customer’s non-cancelled orders by date, using order ID to break date ties.
It returns the customer’s name when the second order was no more than 60 days after the first.
Customers without two non-cancelled orders are excluded.

1. Paste your tables as “table(column, column, …)” or as CREATE TABLE statements, then your question in plain English. Up to 1,500 characters.

2. Pick your database: PostgreSQL, MySQL, SQLite or SQL Server.

3. Press “Write the query”. Without an account you see the start (1 free run a day, no account needed).

4. Run it on a copy or with a LIMIT first, and check a few rows by hand.

• Paste the real columns

  Paste the CREATE TABLE statements, or at least every column you might need. The query can only be as right as the tables it knows.

• Say what one row means

  Say what a row of the answer is: “one row per customer”, “one row per month”. It decides the GROUP BY for you.

• Mention the empty cases

  “Customers who never ordered”, “including months with no sales”: say whether empty cases count, or the query will quietly drop them.

• Big schemas when signed in

  Signed in, paste a much larger schema (up to 20,000 characters) and keep refining the query in the chat.

• The right rows, not just no error

  Run it and look at the rows, not just whether it runs. A query that joins orders to their items can count an order twice; totals that look high usually mean a join multiplied them.

• Only your columns

  Every table and column in the query should be one you gave. An invented column (a “total” your table doesn't have) is the most common way text-to-SQL goes wrong.

• NULLs and missing rows

  Customers with no orders, products never sold, a NULL in the middle of a sum: ask yourself whether they should be in the answer, and check the query agrees.

• Your database's dialect

  Dates, string concatenation and “top N” differ between PostgreSQL, MySQL, SQLite and SQL Server. The query should use your database's way.

• Without an account: 1 free run a day, on GPT-6 Luna, shared with the free message on our home page. It takes up to 1,500 characters, writes up to about 600 tokens (roughly 450 words), and shows you the start of the query.

• Signing up is free, with an email link and no card. llmwise accounts are for people 18 and older. The query you ran comes with you as your first chat, and you get 5 free messages on almost every model (all but Claude Fable 5.1, Claude Opus 5.5, and GPT-6 Astra).

• Signed in, paste up to 20,000 characters in a run. It runs on the model you pick, on your plan, shows the whole answer, and you can carry on in the chat with any model.

More free tools are on the tools page, and what each plan gives is on pricing.