report.md

# PEFT training data report

Built in 158s. Schema fingerprint `a978c48ca1a87c06`, prompt template `2a49640c73fcc680`. This run appended **744** new rows to **971** existing ones.
Total rows: **1715** (train 1441, val 95, test 179); held back until the guardrail allows WITH/UNION: 18.

## By split and tier

| tier | train | val | test |
|---|---|---|---|
| T1 | 284 | 17 | 37 |
| T2 | 463 | 28 | 56 |
| T3 | 471 | 34 | 58 |
| T4 | 143 | 10 | 19 |
| T5 | 80 | 6 | 9 |

## By kind

| kind | rows |
|---|---|
| ask | 1442 |
| followup | 73 |
| repair-exec | 195 |
| repair-parse | 5 |

## By family

| family | rows |
|---|---|
| blocked-set | 6 |
| followup | 73 |
| pilot-gold | 11 |
| spec-inst | 201 |
| spec-inv | 445 |
| spec-pay | 410 |
| spec-supplier | 15 |
| t1-agg | 61 |
| t1-count | 40 |
| t1-date | 8 |
| t1-distinct | 20 |
| t1-topn | 45 |
| t2-gl | 6 |
| t2-having | 16 |
| t2-holds | 1 |
| t2-invoice-lookup | 15 |
| t2-lines | 10 |
| t2-supplier-list | 7 |
| t3-aging | 7 |
| t3-compare | 6 |
| t3-days-to-pay | 5 |
| t3-discount | 10 |
| t3-listagg | 11 |
| t3-overdue | 11 |
| t3-overdue-days | 7 |
| t3-period | 2 |
| t3-upcoming | 8 |
| t4-average | 13 |
| t4-logic | 54 |
| t4-median | 5 |
| t4-mom | 18 |
| t4-rank | 7 |
| t4-running | 10 |
| t4-share | 12 |
| t4-topk | 44 |
| t5-glossary | 95 |

## Prompt size (approx. tokens, 4 chars per token)

min 2027, median 3005, p95 3418, max 3581 (limit 3584)

## Candidates dropped

| reason | count |
|---|---|
| retrieval missed a needed table | 658 |
| duplicate sql | 454 |
| duplicate question | 278 |
| empty or trivial result | 75 |
| repair prompt incomplete or too long | 30 |
| blocked-shape candidate: empty or trivial result | 28 |
| blocked-shape candidate: duplicate | 20 |
| overlaps a pilot question | 4 |

## Retrieval check: did the prompt contain every table the correct SQL needs?

Measured on every templated question that was rendered (kept or not). A miss means the model was not shown a table
it needs; those rows are excluded from training, and each miss is a retrieval problem, not a model problem.

| bucket | rendered | complete | share |
|---|---|---|---|
| T1 | 150 | 150 | 100% |
| T2 | 497 | 240 | 48% |
| T3 | 356 | 210 | 59% |
| T4 | 172 | 14 | 8% |
| T5 | 57 | 7 | 12% |
| followup | 29 | 23 | 79% |

Tables most often missing: POZ_SUPPLIERS (405), AP_INVOICES_ALL (102), POZ_SUPPLIER_ADDRESSES (81), AP_PAYMENT_SCHEDULES_ALL (59), FUN_BUSINESS_UNITS (10), AP_CHECKS_ALL (9), AP_HOLDS_ALL (7), AP_INVOICE_PAYMENTS_ALL (5)


## One example per family

**spec-inv** (T2, ask): Question: 5 payment terms with the lowest total paid against invoices
```sql
SELECT t.NAME, SUM(i.AMOUNT_PAID) AS TOTAL_AMOUNT_PAID
FROM AP_INVOICES_ALL i
JOIN AP_TERMS_B t ON t.TERM_ID = i.TERMS_ID
GROUP BY t.NAME
ORDER BY TOTAL_AMOUNT_PAID ASC
FETCH FIRST 5 ROWS ONLY;
```

**t5-glossary** (T5, ask): Question: What is the largest of the duplicate invoices?
```sql
SELECT MAX(i.INVOICE_AMOUNT)
FROM AP_INVOICES_ALL i
WHERE i.INVOICE_ID IN (SELECT h.INVOICE_ID FROM AP_HOLDS_ALL h WHERE h.HOLD_LOOKUP_CODE = 'DUPLICATE INVOICE');
```

**t1-count** (T1, ask): Question: How many invoices to be paid by wire are there?
```sql
SELECT COUNT(*)
FROM AP_INVOICES_ALL
WHERE PAYMENT_METHOD_CODE = 'WIRE';
```

**spec-inst** (T3, repair-exec): Question: Top 5 suppliers by number of open installments that came due in the last 30 days
```sql
SELECT s.VENDOR_NAME, COUNT(*) AS OPEN_INSTALLMENTS
FROM AP_PAYMENT_SCHEDULES_ALL ps
JOIN AP_INVOICES_ALL i ON i.INVOICE_ID = ps.INVOICE_ID
JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = i.VENDOR_ID
WHERE ps.AMOUNT_REMAINING > 0 AND ps.DUE_DATE >= TRUNC(SYSDATE) - 30
GROUP BY s.VENDOR_NAME
ORDER BY OPEN_INSTALLMENTS DESC
FETCH FIRST 5 ROWS ONLY;
```

**spec-pay** (T2, ask): Question: Show the biggest payment per supplier city for wire payments only
```sql
SELECT a.CITY, MAX(c.AMOUNT) AS MAX_PAYMENT_AMOUNT
FROM AP_CHECKS_ALL c
JOIN POZ_SUPPLIER_ADDRESSES a ON a.VENDOR_ID = c.VENDOR_ID
WHERE c.PAYMENT_METHOD_CODE = 'WIRE'
GROUP BY a.CITY
ORDER BY MAX_PAYMENT_AMOUNT DESC;
```

**t2-invoice-lookup** (T2, ask): Question: When is invoice INV-2026-5034 due and how much is still owed?
```sql
SELECT ps.PAYMENT_NUM, ps.DUE_DATE, ps.AMOUNT_REMAINING
FROM AP_PAYMENT_SCHEDULES_ALL ps
JOIN AP_INVOICES_ALL i ON i.INVOICE_ID = ps.INVOICE_ID
WHERE i.INVOICE_NUM = 'INV-2026-5034'
ORDER BY ps.PAYMENT_NUM;
```

**t4-topk** (T4, ask): Question: For each payment method, show the most recent payment
```sql
SELECT PAYMENT_METHOD_CODE, CHECK_NUMBER, CHECK_DATE, AMOUNT
FROM (
  SELECT c.PAYMENT_METHOD_CODE, c.CHECK_NUMBER, c.CHECK_DATE, c.AMOUNT,
         ROW_NUMBER() OVER (PARTITION BY c.PAYMENT_METHOD_CODE ORDER BY c.CHECK_DATE DESC) AS RN
  FROM AP_CHECKS_ALL c
)
WHERE RN <= 1
ORDER BY PAYMENT_METHOD_CODE, RN;
```

**t3-aging** (T3, ask): Question: Overdue amount by aging bucket: 1-15, 16-30, 31-60 and over 60 days
```sql
SELECT CASE WHEN TRUNC(SYSDATE) - ps.DUE_DATE <= 15 THEN '1-15' WHEN TRUNC(SYSDATE) - ps.DUE_DATE <= 30 THEN '16-30' WHEN TRUNC(SYSDATE) - ps.DUE_DATE <= 60 THEN '31-60' ELSE 'Over 60' END AS AGING_BUCKET, SUM(ps.AMOUNT_REMAINING) AS TOTAL_OVERDUE
FROM AP_PAYMENT_SCHEDULES_ALL ps
WHERE ps.DUE_DATE < TRUNC(SYSDATE) AND ps.AMOUNT_REMAINING > 0
GROUP BY CASE WHEN TRUNC(SYSDATE) - ps.DUE_DATE <= 15 THEN '1-15' WHEN TRUNC(SYSDATE) - ps.DUE_DATE <= 30 THEN '16-30' WHEN TRUNC(SYSDATE) - ps.DUE_DATE <= 60 THEN '31-60' ELSE 'Over 60' END
ORDER BY MAX(ps.DUE_DATE) DESC;
```

**t1-agg** (T1, ask): Question: What is the total invoice amount of manually entered invoices?
```sql
SELECT SUM(INVOICE_AMOUNT)
FROM AP_INVOICES_ALL
WHERE SOURCE = 'MANUAL';
```

**t4-logic** (T4, ask): Question: Suppliers with any payment but no credit memo
```sql
SELECT DISTINCT s.VENDOR_NAME
FROM POZ_SUPPLIERS s
WHERE EXISTS (SELECT 1 FROM AP_CHECKS_ALL c WHERE c.VENDOR_ID = s.VENDOR_ID)
AND NOT EXISTS (SELECT 1 FROM AP_INVOICES_ALL i WHERE i.VENDOR_ID = s.VENDOR_ID AND i.INVOICE_TYPE_LOOKUP_CODE = 'CREDIT')
ORDER BY s.VENDOR_NAME;
```

**t1-topn** (T1, ask): Question: List the most recent 10 invoices
```sql
SELECT INVOICE_NUM, INVOICE_DATE, INVOICE_AMOUNT
FROM AP_INVOICES_ALL
ORDER BY INVOICE_DATE DESC
FETCH FIRST 10 ROWS ONLY;
```

**t4-mom** (T4, ask): Question: Percentage change in payments versus the previous month over the past 12 months
```sql
SELECT MONTH_START, TOTAL_PAYMENT_AMOUNT, ROUND(100 * (TOTAL_PAYMENT_AMOUNT - LAG(TOTAL_PAYMENT_AMOUNT) OVER (ORDER BY MONTH_START)) / NULLIF(LAG(TOTAL_PAYMENT_AMOUNT) OVER (ORDER BY MONTH_START), 0), 1) AS PCT_CHANGE
FROM (
  SELECT TRUNC(c.CHECK_DATE, 'MM') AS MONTH_START, SUM(c.AMOUNT) AS TOTAL_PAYMENT_AMOUNT
  FROM AP_CHECKS_ALL c
  WHERE c.CHECK_DATE >= ADD_MONTHS(TRUNC(SYSDATE), -12)
  GROUP BY TRUNC(c.CHECK_DATE, 'MM')
)
ORDER BY MONTH_START;
```

**t4-rank** (T4, ask): Question: Dense rank suppliers by total payments
```sql
SELECT VENDOR_NAME, TOTAL_PAYMENT_AMOUNT, DENSE_RANK() OVER (ORDER BY TOTAL_PAYMENT_AMOUNT DESC) AS SPEND_RANK
FROM (
  SELECT s.VENDOR_NAME, SUM(c.AMOUNT) AS TOTAL_PAYMENT_AMOUNT
  FROM AP_CHECKS_ALL c
  JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = c.VENDOR_ID
  GROUP BY s.VENDOR_NAME
)
ORDER BY SPEND_RANK;
```

**t3-compare** (T3, ask): Question: Payments this year versus last year by payment method
```sql
SELECT c.PAYMENT_METHOD_CODE,
       SUM(CASE WHEN c.CHECK_DATE >= TRUNC(SYSDATE, 'YYYY') THEN c.AMOUNT ELSE 0 END) AS THIS_YEAR,
       SUM(CASE WHEN c.CHECK_DATE >= ADD_MONTHS(TRUNC(SYSDATE, 'YYYY'), -12) AND c.CHECK_DATE < TRUNC(SYSDATE, 'YYYY') THEN c.AMOUNT ELSE 0 END) AS LAST_YEAR
FROM AP_CHECKS_ALL c
GROUP BY c.PAYMENT_METHOD_CODE
ORDER BY THIS_YEAR DESC;
```

**t2-gl** (T2, ask): Question: Which 3 GL accounts have the highest invoice spend?
```sql
SELECT g.CONCATENATED_SEGMENTS, SUM(d.AMOUNT) AS TOTAL_AMOUNT
FROM AP_INVOICE_DISTRIBUTIONS_ALL d
JOIN GL_CODE_COMBINATIONS g ON g.CODE_COMBINATION_ID = d.DIST_CODE_COMBINATION_ID
GROUP BY g.CONCATENATED_SEGMENTS
ORDER BY TOTAL_AMOUNT DESC
FETCH FIRST 3 ROWS ONLY;
```

**t4-running** (T4, ask): Question: Month by month, what is the cumulative payments?
```sql
SELECT MONTH_START, TOTAL_PAYMENT_AMOUNT, SUM(TOTAL_PAYMENT_AMOUNT) OVER (ORDER BY MONTH_START) AS RUNNING_TOTAL
FROM (
  SELECT TRUNC(c.CHECK_DATE, 'MM') AS MONTH_START, SUM(c.AMOUNT) AS TOTAL_PAYMENT_AMOUNT
  FROM AP_CHECKS_ALL c
  GROUP BY TRUNC(c.CHECK_DATE, 'MM')
)
ORDER BY MONTH_START;
```

**followup** (T2, followup): Question: Break that down by supplier instead
```sql
SELECT s.VENDOR_NAME, SUM(i.INVOICE_AMOUNT) AS TOTAL_INVOICE_AMOUNT
FROM AP_INVOICES_ALL i
JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = i.VENDOR_ID
GROUP BY s.VENDOR_NAME
ORDER BY TOTAL_INVOICE_AMOUNT DESC;
```

**t3-discount** (T3, repair-exec): Question: Which invoices have a discount expiring within 7 days?
```sql
SELECT i.INVOICE_NUM, ps.DISCOUNT_DATE, ps.DISCOUNT_AMOUNT_AVAILABLE
FROM AP_PAYMENT_SCHEDULES_ALL ps
JOIN AP_INVOICES_ALL i ON i.INVOICE_ID = ps.INVOICE_ID
WHERE ps.AMOUNT_REMAINING > 0 AND ps.DISCOUNT_AMOUNT_AVAILABLE > 0 AND ps.DISCOUNT_DATE BETWEEN TRUNC(SYSDATE) AND TRUNC(SYSDATE) + 7
ORDER BY ps.DISCOUNT_DATE;
```

**t4-average** (T4, ask): Question: Which suppliers have total unpaid amount above the average across suppliers?
```sql
SELECT s.VENDOR_NAME, SUM(ps.AMOUNT_REMAINING) AS TOTAL_UNPAID_AMOUNT
FROM AP_PAYMENT_SCHEDULES_ALL ps
JOIN AP_INVOICES_ALL i ON i.INVOICE_ID = ps.INVOICE_ID
JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = i.VENDOR_ID
WHERE ps.AMOUNT_REMAINING > 0
GROUP BY s.VENDOR_NAME
HAVING SUM(ps.AMOUNT_REMAINING) > (
  SELECT AVG(t.TOTAL_UNPAID_AMOUNT)
  FROM (
    SELECT s.VENDOR_NAME, SUM(ps.AMOUNT_REMAINING) AS TOTAL_UNPAID_AMOUNT
    FROM AP_PAYMENT_SCHEDULES_ALL ps
    JOIN AP_INVOICES_ALL i ON i.INVOICE_ID = ps.INVOICE_ID
    JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = i.VENDOR_ID
    WHERE ps.AMOUNT_REMAINING > 0
    GROUP BY s.VENDOR_NAME
  ) t
)
ORDER BY TOTAL_UNPAID_AMOUNT DESC;
```

**t3-overdue** (T3, ask): Question: Overdue amount for installments that are on hold
```sql
SELECT SUM(ps.AMOUNT_REMAINING) AS OVERDUE_ON_HOLD
FROM AP_PAYMENT_SCHEDULES_ALL ps
WHERE ps.DUE_DATE < TRUNC(SYSDATE) AND ps.AMOUNT_REMAINING > 0
AND ps.HOLD_FLAG = 'Y';
```

**t1-distinct** (T1, ask): Question: List the distinct payment statuses
```sql
SELECT DISTINCT STATUS_LOOKUP_CODE
FROM AP_CHECKS_ALL
ORDER BY STATUS_LOOKUP_CODE;
```

**t2-supplier-list** (T2, ask): Question: When did we last pay Vandelay Imports?
```sql
SELECT MAX(c.CHECK_DATE)
FROM AP_CHECKS_ALL c
JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = c.VENDOR_ID
WHERE s.VENDOR_NAME = 'Vandelay Imports';
```

**t2-having** (T2, ask): Question: Suppliers with over 10 invoices
```sql
SELECT s.VENDOR_NAME, COUNT(*) AS INVOICE_COUNT
FROM AP_INVOICES_ALL i
JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = i.VENDOR_ID
GROUP BY s.VENDOR_NAME
HAVING COUNT(*) > 10
ORDER BY INVOICE_COUNT DESC;
```

**blocked-set** (T4, ask): Question: Suppliers with both a payment and a voided payment
```sql
SELECT s.VENDOR_NAME
FROM POZ_SUPPLIERS s
WHERE s.VENDOR_ID IN (
  SELECT VENDOR_ID FROM AP_CHECKS_ALL
  INTERSECT
  SELECT VENDOR_ID FROM AP_CHECKS_ALL WHERE STATUS_LOOKUP_CODE = 'VOIDED'
)
ORDER BY s.VENDOR_NAME;
```

**t4-median** (T4, ask): Question: Median invoice value
```sql
SELECT MEDIAN(i.INVOICE_AMOUNT) AS MEDIAN_INVOICE_AMOUNT
FROM AP_INVOICES_ALL i;
```

**t2-lines** (T2, ask): Question: Total freight charges by supplier
```sql
SELECT s.VENDOR_NAME, SUM(l.AMOUNT) AS TOTAL_FREIGHT_AMOUNT
FROM AP_INVOICE_LINES_ALL l
JOIN AP_INVOICES_ALL i ON i.INVOICE_ID = l.INVOICE_ID
JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = i.VENDOR_ID
WHERE l.LINE_TYPE_LOOKUP_CODE = 'FREIGHT'
GROUP BY s.VENDOR_NAME
ORDER BY TOTAL_FREIGHT_AMOUNT DESC;
```

**spec-supplier** (T3, ask): Question: What is the total amount paid out for Vandelay Imports this year?
```sql
SELECT SUM(c.AMOUNT) AS TOTAL_PAYMENT_AMOUNT
FROM AP_CHECKS_ALL c
JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = c.VENDOR_ID
WHERE s.VENDOR_NAME = 'Vandelay Imports' AND c.CHECK_DATE >= TRUNC(SYSDATE, 'YYYY');
```

**t4-share** (T4, ask): Question: What share of total unpaid amount do the top 5 suppliers account for?
```sql
SELECT s.VENDOR_NAME, SUM(ps.AMOUNT_REMAINING) AS TOTAL_UNPAID_AMOUNT,
       ROUND(100 * RATIO_TO_REPORT(SUM(ps.AMOUNT_REMAINING)) OVER (), 2) AS PCT_OF_TOTAL
FROM AP_PAYMENT_SCHEDULES_ALL ps
JOIN AP_INVOICES_ALL i ON i.INVOICE_ID = ps.INVOICE_ID
JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = i.VENDOR_ID
WHERE ps.AMOUNT_REMAINING > 0
GROUP BY s.VENDOR_NAME
ORDER BY TOTAL_UNPAID_AMOUNT DESC
FETCH FIRST 5 ROWS ONLY;
```

**t1-date** (T1, ask): Question: When was the oldest invoice invoice date?
```sql
SELECT MIN(INVOICE_DATE)
FROM AP_INVOICES_ALL;
```

**t2-holds** (T2, ask): Question: Average days to release a hold by hold reason
```sql
SELECT h.HOLD_LOOKUP_CODE, ROUND(AVG(h.RELEASE_DATE - h.HOLD_DATE), 1) AS AVG_DAYS_TO_RELEASE
FROM AP_HOLDS_ALL h
WHERE h.RELEASE_DATE IS NOT NULL
GROUP BY h.HOLD_LOOKUP_CODE
ORDER BY AVG_DAYS_TO_RELEASE DESC;
```

**t3-upcoming** (T3, ask): Question: How much is due in the rest of this month?
```sql
SELECT SUM(ps.AMOUNT_REMAINING) AS TOTAL_DUE
FROM AP_PAYMENT_SCHEDULES_ALL ps
WHERE ps.AMOUNT_REMAINING > 0 AND ps.DUE_DATE BETWEEN TRUNC(SYSDATE) AND LAST_DAY(TRUNC(SYSDATE));
```

**t3-days-to-pay** (T3, ask): Question: Do wires get paid faster than checks? Show average days to pay by method
```sql
SELECT c.PAYMENT_METHOD_CODE, ROUND(AVG(c.CHECK_DATE - i.INVOICE_DATE), 1) AS AVG_DAYS_TO_PAY
FROM AP_INVOICE_PAYMENTS_ALL ip
JOIN AP_CHECKS_ALL c ON c.CHECK_ID = ip.CHECK_ID
JOIN AP_INVOICES_ALL i ON i.INVOICE_ID = ip.INVOICE_ID
WHERE c.STATUS_LOOKUP_CODE <> 'VOIDED'
GROUP BY c.PAYMENT_METHOD_CODE
ORDER BY AVG_DAYS_TO_PAY;
```

**t3-overdue-days** (T3, repair-exec): Question: Which suppliers have invoices more than 30 days overdue?
```sql
SELECT DISTINCT s.VENDOR_NAME
FROM AP_PAYMENT_SCHEDULES_ALL ps
JOIN AP_INVOICES_ALL i ON i.INVOICE_ID = ps.INVOICE_ID
JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = i.VENDOR_ID
WHERE ps.AMOUNT_REMAINING > 0
AND TRUNC(SYSDATE) - ps.DUE_DATE > 30
ORDER BY s.VENDOR_NAME;
```

**t3-listagg** (T3, ask): Question: Show every supplier with a comma-separated list of the invoice types they have sent
```sql
SELECT VENDOR_NAME, LISTAGG(INVOICE_TYPE_LOOKUP_CODE, ', ') WITHIN GROUP (ORDER BY INVOICE_TYPE_LOOKUP_CODE) AS VALUES_LIST
FROM (
  SELECT DISTINCT s.VENDOR_NAME, i.INVOICE_TYPE_LOOKUP_CODE
  FROM AP_INVOICES_ALL i
  JOIN POZ_SUPPLIERS s ON s.VENDOR_ID = i.VENDOR_ID
)
GROUP BY VENDOR_NAME
ORDER BY VENDOR_NAME;
```

**t3-period** (T3, ask): Question: Weekly invoice count for the past 3 months
```sql
SELECT TRUNC(i.INVOICE_DATE, 'IW') AS WEEK_START, COUNT(*) AS INVOICE_COUNT
FROM AP_INVOICES_ALL i
WHERE i.INVOICE_DATE >= ADD_MONTHS(TRUNC(SYSDATE), -3)
GROUP BY TRUNC(i.INVOICE_DATE, 'IW')
ORDER BY WEEK_START;
```

**pilot-gold** (T1, ask): Question: How many holds are still active, by hold reason?
```sql
SELECT HOLD_LOOKUP_CODE, COUNT(*) FROM AP_HOLDS_ALL WHERE RELEASE_DATE IS NULL GROUP BY HOLD_LOOKUP_CODE;
```