System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.appointments (
    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment
    patient_id character varying(64) NOT NULL, -- FK to patients table
    doctor_id character varying(64) NOT NULL, -- FK to doctors table
    appointment_time timestamp with time zone NOT NULL, -- date and time of the appointment
    duration_minutes integer NOT NULL, -- expected duration in minutes
    reason text, -- reason for the visit
    status character varying(32) NOT NULL, -- e.g., Scheduled, Completed, Cancelled, No-show
    location_id character varying(64), -- FK to a potential locations/clinics table
    notes text, -- notes related to scheduling
    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
    PRIMARY KEY (appointment_id)
)
CREATE TABLE healthcare.medical_records (
    record_id character varying(64) NOT NULL,  -- unique identifier for the medical record entry
    patient_id character varying(64) NOT NULL, -- FK to patients table
    appointment_id character varying(64) UNIQUE, -- FK to appointments table (can be null if record not tied to specific appt)
    doctor_id character varying(64) NOT NULL, -- FK to doctors table (doctor creating the record)
    record_date timestamp with time zone NOT NULL, -- date the record/observation was made
    chief_complaint text, -- patient's primary reason for visit
    present_illness_history text, -- detailed history of the current issue
    past_medical_history text, -- relevant past conditions/surgeries
    physical_examination_notes text, -- findings from the physical exam
    assessment text, -- doctor's assessment/diagnosis summary
    treatment_plan text, -- planned course of action
    vitals jsonb, -- store vitals like BP, HR, Temp as structured JSON
    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
    PRIMARY KEY (record_id)
)
CREATE TABLE healthcare.insurance_plans (
    plan_id character varying(64) NOT NULL, -- unique identifier for the insurance plan
    plan_name character varying(200) NOT NULL, -- name of the insurance plan
    insurance_provider character varying(100) NOT NULL, -- name of the insurance company
    plan_type character varying(50), -- e.g., PPO, HMO, EPO
    contact_phone character varying(20), -- provider contact number
    website character varying(255), -- provider website
    PRIMARY KEY (plan_id)
)
CREATE TABLE healthcare.patient_insurance (
    patient_insurance_id character varying(64) NOT NULL, -- unique identifier for this patient-plan link
    patient_id character varying(64) NOT NULL, -- FK to patients table
    plan_id character varying(64) NOT NULL, -- FK to insurance_plans table
    policy_number character varying(100) NOT NULL, -- patient's policy number
    group_number character varying(100), -- group number, if applicable
    subscriber_name character varying(200), -- name of the primary policy holder
    effective_date date NOT NULL, -- date the coverage begins
    expiration_date date, -- date the coverage ends (if known)
    is_primary boolean NOT NULL DEFAULT true, -- indicates if this is the primary insurance
    PRIMARY KEY (patient_insurance_id),
    UNIQUE (patient_id, plan_id, policy_number) -- ensure a patient doesn't have the same policy twice
)

[User] For each scheduled appointment, list the appointment_id, appointment_time, patient_id, and the name of the patient's primary insurance plan. Only include appointments that have not been cancelled.

[Assistant]
SELECT a.appointment_id,
       a.appointment_time,
       a.patient_id,
       ip.plan_name
FROM healthcare.appointments a
JOIN healthcare.patient_insurance pi
  ON a.patient_id = pi.patient_id
 AND pi.is_primary = TRUE
JOIN healthcare.insurance_plans ip
  ON pi.plan_id = ip.plan_id
WHERE a.status != 'Cancelled';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.doctors ( doctor_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, specialty character varying(100) NOT NULL, license_number character varying(50) UNIQUE NOT NULL, phone_number character varying(20), email character varying(128) UNIQUE, hospital_affiliation_id character varying(64), created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (doctor_id) )
CREATE TABLE healthcare.appointments ( appointment_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, appointment_time timestamp with time zone NOT NULL, duration_minutes integer NOT NULL, reason text, status character varying(32) NOT NULL, location_id character varying(64), notes text, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (appointment_id) )
CREATE TABLE healthcare.medical_records ( record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, appointment_id character varying(64) UNIQUE, doctor_id character varying(64) NOT NULL, record_date timestamp with time zone NOT NULL, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals jsonb, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (record_id) )
CREATE TABLE healthcare.diagnoses ( diagnosis_id character varying(64) NOT NULL, record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, diagnosis_code character varying(20) NOT NULL, code_type character varying(10) NOT NULL DEFAULT 'ICD-10', description text, diagnosis_date date NOT NULL, status character varying(32) NOT NULL, is_chronic boolean DEFAULT false, PRIMARY KEY (diagnosis_id) )
CREATE TABLE healthcare.insurance_plans ( plan_id character varying(64) NOT NULL, plan_name character varying(200) NOT NULL, insurance_provider character varying(100) NOT NULL, plan_type character varying(50), contact_phone character varying(20), website character varying(255), PRIMARY KEY (plan_id) )
CREATE TABLE healthcare.patient_insurance ( patient_insurance_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, plan_id character varying(64) NOT NULL, policy_number character varying(100) NOT NULL, group_number character varying(100), subscriber_name character varying(200), effective_date date NOT NULL, expiration_date date, is_primary boolean NOT NULL DEFAULT true, PRIMARY KEY (patient_insurance_id), UNIQUE (patient_id, plan_id, policy_number) )

[User] Can you show me the count of new doctors added each month in 2023? Return the month and number of doctors.

[Assistant]
SELECT DATE_TRUNC('month', created_at) AS month, COUNT(*) AS doctor_count
FROM healthcare.doctors
WHERE created_at >= '2023-01-01' AND created_at < '2024-01-01'
GROUP BY DATE_TRUNC('month', created_at);

[User] Actually, include the month as the first day of the month and order the results by month in descending order.

[Assistant]
SELECT DATE_TRUNC('month', created_at)::date AS month_start, COUNT(*) AS doctor_count
FROM healthcare.doctors
WHERE created_at >= '2023-01-01' AND created_at < '2024-01-01'
GROUP BY DATE_TRUNC('month', created_at)
ORDER BY month_start DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.patients ( patient_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, date_of_birth date NOT NULL, gender character varying(10), address text, phone_number character varying(20), email character varying(128) UNIQUE, emergency_contact_name character varying(200), emergency_contact_phone character varying(20), created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (patient_id) )
CREATE TABLE healthcare.appointments ( appointment_id text, patient_id text, doctor_id text, appointment_time timestamp, duration_minutes integer, reason text, status text, location_id text, notes text, created_at timestamp )
CREATE TABLE healthcare.medical_records ( record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, appointment_id character varying(64) UNIQUE, doctor_id character varying(64) NOT NULL, record_date timestamp with time zone NOT NULL, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals jsonb, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (record_id) )
CREATE TABLE healthcare.diagnoses ( diagnosis_id text PRIMARY KEY, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )
CREATE TABLE healthcare.medications ( medication_id text, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )
CREATE TABLE healthcare.prescriptions ( prescription_id.text, record_id.text, patient_id.text, doctor_id.text, medication_id.text, dosage.text, frequency.text, route.text, start_date.date, end_date.date, quantity_dispensed.numeric, refills_allowed.integer, prescription_date.timestamp )
CREATE TABLE healthcare.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )
CREATE TABLE healthcare.patient_insurance ( patient_insurance_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, plan_id character varying(64) NOT NULL, policy_number character varying(100) NOT NULL, group_number character varying(100), subscriber_name character varying(200), effective_date date NOT NULL, expiration_date date, is_primary boolean NOT NULL DEFAULT true, PRIMARY KEY (patient_insurance_id), UNIQUE (patient_id, plan_id, policy_number) )

[User] List each patient's first and last name along with the insurance plan name they are enrolled in, including only primary policies. Return patient_id, first_name, last_name, and plan_name.

[Assistant]
SELECT p.patient_id,
       p.first_name,
       p.last_name,
       ip.plan_name
FROM healthcare.patients AS p
JOIN healthcare.patient_insurance AS pi
  ON p.patient_id = pi.patient_id AND pi.is_primary = true
JOIN healthcare.insurance_plans AS ip ON pi.plan_id = ip.plan_id;

[User] Now limit to plans with plan_type 'EPO' and sort by patient last name ascending.

[Assistant]
SELECT p.patient_id,
       p.first_name,
       p.last_name,
       ip.plan_name
FROM healthcare.patients AS p
JOIN healthcare.patient_insurance AS pi
  ON p.patient_id = pi.patient_id AND pi.is_primary = true
JOIN healthcare.insurance_plans AS ip ON pi.plan_id = ip.plan_id
WHERE ip.plan_type = 'EPO'
ORDER BY p.last_name ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.medications ( medication_id character varying(64) NOT NULL, medication_name character varying(255) NOT NULL, generic_name character varying(255), manufacturer character varying(100), ndc_code character varying(20) UNIQUE, description text, PRIMARY KEY (medication_id) )

[User] List the NDC code and description for any medication that has an NDC code starting with '5'.

[Assistant] SELECT ndc_code, description FROM healthcare.medications WHERE ndc_code LIKE '5%';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.medications (
    medication_id character varying(64) NOT NULL, -- unique identifier for the medication type
    medication_name character varying(255) NOT NULL, -- common or brand name
    generic_name character varying(255), -- generic chemical name
    manufacturer character varying(100), -- drug manufacturer
    ndc_code character varying(20) UNIQUE, -- National Drug Code (optional but useful)
    description text, -- description of the medication
    PRIMARY KEY (medication_id)
)

[User] List the medication_id, medication_name, and description for all medications whose generic_name starts with 'A'.

[Assistant]
SELECT medication_id, medication_name, description
FROM healthcare.medications
WHERE generic_name LIKE 'A%';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.medical_records (
    record_id character varying(64) NOT NULL,  -- unique identifier for the medical record entry
    patient_id character varying(64) NOT NULL, -- FK to patients table
    appointment_id character varying(64) UNIQUE, -- FK to appointments table (can be null if record not tied to specific appt)
    doctor_id character varying(64) NOT NULL, -- FK to doctors table (doctor creating the record)
    record_date timestamp with time zone NOT NULL, -- date the record/observation was made
    chief_complaint text, -- patient's primary reason for visit
    present_illness_history text, -- detailed history of the current issue
    past_medical_history text, -- relevant past conditions/surgeries
    physical_examination_notes text, -- findings from the physical exam
    assessment text, -- doctor's assessment/diagnosis summary
    treatment_plan text, -- planned course of action
    vitals jsonb, -- store vitals like BP, HR, Temp as structured JSON
    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
    PRIMARY KEY (record_id)
)
CREATE TABLE healthcare.patient_insurance ( patient_insurance_id text PRIMARY KEY, patient_id text, plan_id text, policy_number text, group_number text, subscriber_name text, effective_date date, expiration_date date, is_primary boolean )

[User] Show the record_id, patient_id, record_date and systolic blood pressure from vitals for all medical records where the systolic blood pressure is above 140.

[Assistant]
SELECT record_id, patient_id, record_date, (vitals->>'systolic')::INT AS systolic
FROM healthcare.medical_records
WHERE (vitals->>'systolic')::INT > 140;

[User] Only include those records for patients who currently have a primary insurance that is active.

[Assistant]
SELECT mr.record_id, mr.patient_id, mr.record_date, (mr.vitals->>'systolic')::INT AS systolic
FROM healthcare.medical_records mr
JOIN healthcare.patient_insurance pi ON mr.patient_id = pi.patient_id
WHERE (mr.vitals->>'systolic')::INT > 140
  AND pi.is_primary = TRUE
  AND pi.effective_date <= CURRENT_DATE
  AND (pi.expiration_date IS NULL OR pi.expiration_date > CURRENT_DATE);


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.prescriptions (
    prescription_id character varying(64) NOT NULL, -- unique identifier for the prescription
    record_id character varying(64) NOT NULL, -- FK linking to the medical record where it was prescribed
    patient_id character varying(64) NOT NULL, -- FK to patients table
    doctor_id character varying(64) NOT NULL, -- FK to prescribing doctor
    medication_id character varying(64) NOT NULL, -- FK to medications table
    dosage character varying(100) NOT NULL, -- e.g., '100mg', '1 tablet'
    frequency character varying(100) NOT NULL, -- e.g., 'Once daily', 'Twice a day with meals'
    route character varying(50), -- e.g., 'Oral', 'Topical', 'Intravenous'
    start_date date NOT NULL, -- date prescription begins
    end_date date, -- date prescription ends (if applicable)
    quantity_dispensed numeric(10,2), -- amount dispensed (e.g., number of tablets)
    refills_allowed integer NOT NULL DEFAULT 0, -- number of allowed refills
    prescription_date timestamp with time zone NOT NULL DEFAULT current_timestamp,
    PRIMARY KEY (prescription_id)
)

[User] Which doctors have issued prescriptions with a route of 'Oral'? Please show doctor_id and the number of such prescriptions they have written.

[Assistant]
SELECT doctor_id, COUNT(*) AS oral_prescription_count
FROM healthcare.prescriptions
WHERE route = 'Oral'
GROUP BY doctor_id;

[User] Now, only include doctors who have written more than 10 oral prescriptions and sort the list by oral_prescription_count descending.

[Assistant]
SELECT doctor_id, COUNT(*) AS oral_prescription_count
FROM healthcare.prescriptions
WHERE route = 'Oral'
GROUP BY doctor_id
HAVING COUNT(*) > 10
ORDER BY oral_prescription_count DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.appointments ( appointment_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, appointment_time timestamp with time zone NOT NULL, duration_minutes integer NOT NULL, reason text, status character varying(32) NOT NULL, location_id character varying(64), notes text, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (appointment_id) )

[User] Show the total number of appointments created in 2024 for each doctor and each status.

[Assistant] SELECT doctor_id, status, COUNT(*) AS appointment_count FROM healthcare.appointments WHERE EXTRACT(YEAR FROM created_at) = 2024 GROUP BY doctor_id, status;

[User] Only include combinations where the count is greater than 5.

[Assistant] SELECT doctor_id, status, COUNT(*) AS appointment_count FROM healthcare.appointments WHERE EXTRACT(YEAR FROM created_at) = 2024 GROUP BY doctor_id, status HAVING COUNT(*) > 5;

[User] Sort the results by doctor ID ascending and then by appointment count descending.

[Assistant] SELECT doctor_id, status, COUNT(*) AS appointment_count FROM healthcare.appointments WHERE EXTRACT(YEAR FROM created_at) = 2024 GROUP BY doctor_id, status HAVING COUNT(*) > 5 ORDER BY doctor_id ASC, appointment_count DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.customers ( customer_id text, first_name text, last_name text, date_of_birth date, ssn_hash text, address text, city text, state text, zip_code text, country text, email text, phone_number text, created_at timestamp, status text, risk_profile text )
CREATE TABLE financial_services.transactions ( transaction_id text, account_id text, related_account_id text, transaction_type text, amount numeric, currency text, transaction_date timestamp, effective_date date, description text, status text, reference_number text )
CREATE TABLE financial_services.securities ( security_id.text, ticker_symbol.text, isin_code.text, cusip_code.text, security_name.text, security_type.text, exchange.text, currency.text, issuer_name.text, sector.text, last_updated.timestamp )
CREATE TABLE financial_services.market_data ( data_point_id bigserial NOT NULL, security_id character varying(64) NOT NULL, data_timestamp timestamp NOT NULL, open_price numeric(19, 8), high_price numeric(19, 8), low_price numeric(19, 8), close_price numeric(19, 8) NOT NULL, adjusted_close_price numeric(19, 8), volume bigint, source character varying(50), PRIMARY KEY (data_point_id), UNIQUE (security_id, data_timestamp), FOREIGN KEY (security_id) REFERENCES financial_services.securities(security_id) )
CREATE TABLE financial_services.employees (
    employee_id character varying(64) NOT NULL,  -- unique identifier for the employee
    first_name character varying(100) NOT NULL,
    last_name character varying(100) NOT NULL,
    job_title character varying(100) NOT NULL, -- e.g., Teller, Branch Manager, Financial Advisor, Analyst
    department character varying(100), -- e.g., Retail Banking, Wealth Management, IT
    branch_id character varying(64), -- Identifier for the branch they work at (if applicable)
    email character varying(128) NOT NULL UNIQUE,
    phone_extension character varying(20),
    hire_date date NOT NULL,
    termination_date date, -- Date of termination, null if currently employed
    manager_id character varying(64), -- Self-referencing key for manager relationship
    status character varying(32) NOT NULL, -- e.g., Active, Terminated, On Leave
    PRIMARY KEY (employee_id),
    FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), -- Assuming a branches table exists
    FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id)
)

[User] List all employees hired in 2023 along with their job title and email.

[Assistant]
SELECT employee_id, first_name, last_name, job_title, email
FROM financial_services.employees
WHERE EXTRACT(YEAR FROM hire_date) = 2023;

[User] Can you also include the full name of their direct manager for each employee?

[Assistant]
SELECT e.employee_id, e.first_name, e.last_name, e.job_title, e.email, CONCAT(m.first_name, ' ', m.last_name) AS manager_full_name
FROM financial_services.employees e
LEFT JOIN financial_services.employees m ON e.manager_id = m.employee_id
WHERE EXTRACT(YEAR FROM e.hire_date) = 2023;

[User] Now limit the output to only employees who are currently 'Active'.

[Assistant]
SELECT e.employee_id, e.first_name, e.last_name, e.job_title, e.email, CONCAT(m.first_name, ' ', m.last_name) AS manager_full_name
FROM financial_services.employees e
LEFT JOIN financial_services.employees m ON e.manager_id = m.employee_id
WHERE EXTRACT(YEAR FROM e.hire_date) = 2023 AND e.status = 'Active';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.securities (
    security_id character varying(64) NOT NULL, -- unique identifier for the security
    ticker_symbol character varying(20) NOT NULL UNIQUE, -- stock ticker or fund symbol
    isin_code character varying(12) UNIQUE, -- International Securities Identification Number
    cusip_code character varying(9) UNIQUE, -- CUSIP number
    security_name text NOT NULL, -- full name of the security
    security_type character varying(50) NOT NULL, -- e.g., Stock, Bond, ETF, Mutual Fund, Option, Future
    exchange character varying(50), -- primary exchange where traded (e.g., NYSE, NASDAQ)
    currency character varying(3) NOT NULL, -- currency the security is denominated in
    issuer_name character varying(255), -- name of the issuing entity
    sector character varying(100), -- industry sector
    last_updated timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (security_id)
)

[User] List pairs of securities that trade on different exchanges but belong to the same sector, showing ticker_symbol of both as symbol_a and symbol_b, their exchanges, and the sector.

[Assistant]
SELECT a.ticker_symbol AS symbol_a, a.exchange AS exchange_a, b.ticker_symbol AS symbol_b, b.exchange AS exchange_b, a.sector
FROM financial_services.securities a
JOIN financial_services.securities b
  ON a.sector = b.sector
  AND a.exchange <> b.exchange
WHERE a.ticker_symbol < b.ticker_symbol;

[User] Actually, exclude any pairs where the sector is NULL and ensure uniqueness by requiring symbol_a < symbol_b.

[Assistant]
SELECT a.ticker_symbol AS symbol_a, a.exchange AS exchange_a, b.ticker_symbol AS symbol_b, b.exchange AS exchange_b, a.sector
FROM financial_services.securities a
JOIN financial_services.securities b
  ON a.sector = b.sector
  AND a.exchange <> b.exchange
WHERE a.sector IS NOT NULL
  AND a.ticker_symbol < b.ticker_symbol;

[User] Now also order the results by sector ascending and symbol_a ascending.

[Assistant]
SELECT a.ticker_symbol AS symbol_a, a.exchange AS exchange_a, b.ticker_symbol AS symbol_b, b.exchange AS exchange_b, a.sector
FROM financial_services.securities a
JOIN financial_services.securities b
  ON a.sector = b.sector
  AND a.exchange <> b.exchange
WHERE a.sector IS NOT NULL
  AND a.ticker_symbol < b.ticker_symbol
ORDER BY a.sector ASC, a.ticker_symbol ASC;

[User] Finally, only include pairs where both securities are denominated in USD.

[Assistant]
SELECT a.ticker_symbol AS symbol_a, a.exchange AS exchange_a, b.ticker_symbol AS symbol_b, b.exchange AS exchange_b, a.sector
FROM financial_services.securities a
JOIN financial_services.securities b
  ON a.sector = b.sector
  AND a.exchange <> b.exchange
WHERE a.sector IS NOT NULL
  AND a.currency = 'USD'
  AND b.currency = 'USD'
  AND a.ticker_symbol < b.ticker_symbol
ORDER BY a.sector ASC, a.ticker_symbol ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.accounts ( account_id text PRIMARY KEY, customer_id text, account_number text, account_type text, balance numeric, currency text, opened_date date, status text, interest_rate numeric, last_updated_at timestamp )

[User] Show me the average interest rate for each account_type.

[Assistant]
SELECT account_type, AVG(interest_rate) AS average_interest_rate
FROM financial_services.accounts
GROUP BY account_type;

[User] Only include account types with at least 5 accounts and order by average_interest_rate ascending.

[Assistant]
SELECT account_type, AVG(interest_rate) AS average_interest_rate, COUNT(*) AS account_count
FROM financial_services.accounts
GROUP BY account_type
HAVING COUNT(*) >= 5
ORDER BY average_interest_rate ASC;

[User] Add the minimum and maximum interest rate for each account_type to the result.

[Assistant]
SELECT account_type, COUNT(*) AS account_count, AVG(interest_rate) AS average_interest_rate,
       MIN(interest_rate) AS min_interest_rate, MAX(interest_rate) AS max_interest_rate
FROM financial_services.accounts
GROUP BY account_type
HAVING COUNT(*) >= 5
ORDER BY average_interest_rate ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.transactions ( transaction_id character varying(64) NOT NULL, account_id character varying(64) NOT NULL, related_account_id character varying(64), transaction_type character varying(50) NOT NULL, amount numeric(19, 4) NOT NULL, currency character varying(3) NOT NULL, transaction_date timestamp NOT NULL, effective_date date NOT NULL, description text, status character varying(32) NOT NULL, reference_number character varying(128), PRIMARY KEY (transaction_id), FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id), FOREIGN KEY (related_account_id) REFERENCES financial_services.accounts(account_id) )
CREATE TABLE financial_services.trades ( trade_id text PRIMARY KEY, account_id text, security_id text, order_id text, trade_type text, quantity numeric, price_per_unit numeric, total_amount numeric, commission numeric, trade_timestamp timestamp, settlement_date date, status text, execution_venue text )
CREATE TABLE financial_services.employees ( employee_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, job_title character varying(100) NOT NULL, department character varying(100), branch_id character varying(64), email character varying(128) NOT NULL UNIQUE, phone_extension character varying(20), hire_date date NOT NULL, termination_date date, manager_id character varying(64), status character varying(32) NOT NULL, PRIMARY KEY (employee_id), FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id) )

[User] Show me all transactions with a status of 'FAILED' that occurred within the last 7 days.

[Assistant] SELECT * FROM financial_services.transactions WHERE status = 'FAILED' AND transaction_date >= NOW() - INTERVAL '7 day';

[User] Only show the transaction_id, account_id, amount, and description for these transactions.

[Assistant] SELECT transaction_id, account_id, amount, description FROM financial_services.transactions WHERE status = 'FAILED' AND transaction_date >= NOW() - INTERVAL '7 day';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.customers ( customer_id text PRIMARY KEY, first_name text, last_name text, date_of_birth date, ssn_hash text, address text, city text, state text, zip_code text, country text, email text, phone_number text, created_at timestamp, status text, risk_profile text )
CREATE TABLE financial_services.accounts ( account_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, account_number character varying(128) NOT NULL UNIQUE, account_type character varying(50) NOT NULL, balance numeric(19, 4) NOT NULL DEFAULT 0.00, currency character varying(3) NOT NULL, opened_date date NOT NULL, status character varying(32) NOT NULL, interest_rate numeric(5, 4), last_updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (account_id), FOREIGN KEY (customer_id) REFERENCES financial_services.customers(customer_id) )
CREATE TABLE financial_services.transactions ( transaction_id character varying(64) NOT NULL, account_id character varying(64) NOT NULL, related_account_id character varying(64), transaction_type character varying(50) NOT NULL, amount numeric(19, 4) NOT NULL, currency character varying(3) NOT NULL, transaction_date timestamp NOT NULL, effective_date date NOT NULL, description text, status character varying(32) NOT NULL, reference_number character varying(128), PRIMARY KEY (transaction_id), FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id), FOREIGN KEY (related_account_id) REFERENCES financial_services.accounts(account_id) )
CREATE TABLE financial_services.trades ( trade_id text PRIMARY KEY, account_id text, security_id text, order_id text, trade_type text, quantity numeric, price_per_unit numeric, total_amount numeric, commission numeric, trade_timestamp timestamp, settlement_date date, status text, execution_venue text )
CREATE TABLE financial_services.market_data (
    data_point_id bigserial NOT NULL, -- auto-incrementing primary key
    security_id character varying(64) NOT NULL, -- identifier for the security
    data_timestamp timestamp NOT NULL, -- timestamp for the data point (e.g., end of day, intraday)
    open_price numeric(19, 8), -- opening price for the period
    high_price numeric(19, 8), -- highest price during the period
    low_price numeric(19, 8), -- lowest price during the period
    close_price numeric(19, 8) NOT NULL, -- closing price for the period
    adjusted_close_price numeric(19, 8), -- closing price adjusted for dividends and splits
    volume bigint, -- trading volume during the period
    source character varying(50), -- source of the market data (e.g., Bloomberg, Refinitiv)
    PRIMARY KEY (data_point_id),
    UNIQUE (security_id, data_timestamp), -- Ensure unique data point per security per time
    FOREIGN KEY (security_id) REFERENCES financial_services.securities(security_id)
)
CREATE TABLE financial_services.employees ( employee_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, job_title character varying(100) NOT NULL, department character varying(100), branch_id character varying(64), email character varying(128) NOT NULL UNIQUE, phone_extension character varying(20), hire_date date NOT NULL, termination_date date, manager_id character varying(64), status character varying(32) NOT NULL, PRIMARY KEY (employee_id), FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id) )
CREATE TABLE financial_services.loans ( loan_id.text, account_id.text, loan_type.text, principal_amount.numeric, current_principal_balance.numeric, interest_rate.numeric, term_months.integer, origination_date.date, maturity_date.date, monthly_payment.numeric, collateral_description.text, status.text )

[User] Show me a summary of customers with their total account balance and the count of accounts.

[Assistant] SELECT c.first_name, c.last_name, COUNT(a.account_id) AS account_count, SUM(a.balance) AS total_account_balance FROM financial_services.customers AS c JOIN financial_services.accounts AS a ON c.customer_id = a.customer_id GROUP BY c.customer_id, c.first_name, c.last_name;

[User] Filter the results to only include customers where the combined balance across all their accounts exceeds 5000.

[Assistant] SELECT c.first_name, c.last_name, COUNT(a.account_id) AS account_count, SUM(a.balance) AS total_account_balance FROM financial_services.customers AS c JOIN financial_services.accounts AS a ON c.customer_id = a.customer_id GROUP BY c.customer_id, c.first_name, c.last_name HAVING SUM(a.balance) > 5000;

[User] Please modify the query to only count and sum balances for accounts with status 'ACTIVE'.

[Assistant] SELECT c.first_name, c.last_name, COUNT(CASE WHEN a.status = 'ACTIVE' THEN a.account_id ELSE NULL END) AS active_account_count, SUM(CASE WHEN a.status = 'ACTIVE' THEN a.balance ELSE 0 END) AS total_active_account_balance FROM financial_services.customers AS c JOIN financial_services.accounts AS a ON c.customer_id = a.customer_id GROUP BY c.customer_id, c.first_name, c.last_name HAVING SUM(CASE WHEN a.status = 'ACTIVE' THEN a.balance ELSE 0 END) > 5000;

[User] Order the results by customer last name, then first name.

[Assistant] SELECT c.first_name, c.last_name, COUNT(CASE WHEN a.status = 'ACTIVE' THEN a.account_id ELSE NULL END) AS active_account_count, SUM(CASE WHEN a.status = 'ACTIVE' THEN a.balance ELSE 0 END) AS total_active_account_balance FROM financial_services.customers AS c JOIN financial_services.accounts AS a ON c.customer_id = a.customer_id GROUP BY c.customer_id, c.first_name, c.last_name HAVING SUM(CASE WHEN a.status = 'ACTIVE' THEN a.balance ELSE 0 END) > 5000 ORDER BY c.last_name ASC, c.first_name ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.accounts (
    account_id character varying(64) NOT NULL, -- unique identifier for the account
    customer_id character varying(64) NOT NULL, -- foreign key linking to the customer
    account_number character varying(128) NOT NULL UNIQUE, -- unique account number visible to customer
    account_type character varying(50) NOT NULL, -- e.g., Checking, Savings, Investment, Loan, Credit Card
    balance numeric(19, 4) NOT NULL DEFAULT 0.00, -- current account balance
    currency character varying(3) NOT NULL, -- currency code (e.g., USD, EUR)
    opened_date date NOT NULL, -- date the account was opened
    status character varying(32) NOT NULL, -- e.g., Open, Closed, Frozen
    interest_rate numeric(5, 4), -- annual interest rate, if applicable
    last_updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last account update
    PRIMARY KEY (account_id),
    FOREIGN KEY (customer_id) REFERENCES financial_services.customers(customer_id)
)

[User] Can you provide a breakdown of total and average account balance by account_type and currency for each account status?

[Assistant]
SELECT account_type, currency, status, COUNT(*) AS total_accounts, SUM(balance) AS total_balance, AVG(balance) AS average_balance
FROM financial_services.accounts
GROUP BY account_type, currency, status;

[User] Could you include the minimum and maximum interest rate for each group as well?

[Assistant]
SELECT account_type, currency, status, COUNT(*) AS total_accounts, SUM(balance) AS total_balance, AVG(balance) AS average_balance, MIN(interest_rate) AS min_interest_rate, MAX(interest_rate) AS max_interest_rate
FROM financial_services.accounts
GROUP BY account_type, currency, status;

[User] Only show groups where the total_accounts is greater than 20.

[Assistant]
SELECT account_type, currency, status, COUNT(*) AS total_accounts, SUM(balance) AS total_balance, AVG(balance) AS average_balance, MIN(interest_rate) AS min_interest_rate, MAX(interest_rate) AS max_interest_rate
FROM financial_services.accounts
GROUP BY account_type, currency, status
HAVING COUNT(*) > 20;

[User] Please sort the results by average_balance in descending order.

[Assistant]
SELECT account_type, currency, status, COUNT(*) AS total_accounts, SUM(balance) AS total_balance, AVG(balance) AS average_balance, MIN(interest_rate) AS min_interest_rate, MAX(interest_rate) AS max_interest_rate
FROM financial_services.accounts
GROUP BY account_type, currency, status
HAVING COUNT(*) > 20
ORDER BY average_balance DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.accounts ( account_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, account_number character varying(128) NOT NULL UNIQUE, account_type character varying(50) NOT NULL, balance numeric(19, 4) NOT NULL DEFAULT 0.00, currency character varying(3) NOT NULL, opened_date date NOT NULL, status character varying(32) NOT NULL, interest_rate numeric(5, 4), last_updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (account_id), FOREIGN KEY (customer_id) REFERENCES financial_services.customers(customer_id) )

[User] What is the total balance for each currency in the accounts table?

[Assistant] SELECT currency, SUM(balance) AS total_balance FROM financial_services.accounts GROUP BY currency;

[User] Can you also show the number of accounts for each currency?

[Assistant] SELECT currency, COUNT(account_id) AS number_of_accounts, SUM(balance) AS total_balance FROM financial_services.accounts GROUP BY currency;

[User] Only include accounts with status 'ACTIVE' in the calculation.

[Assistant] SELECT currency, COUNT(account_id) AS number_of_accounts, SUM(balance) AS total_balance FROM financial_services.accounts WHERE status = 'ACTIVE' GROUP BY currency;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.accounts ( account_id.text, customer_id.text, account_number.text, account_type.text, balance.numeric, currency.text, opened_date.date, status.text, interest_rate.numeric, last_updated_at.timestamp )

[User] Find customers who have accounts in more than one currency. List their customer_id and the count of distinct currencies they hold accounts in.

[Assistant] SELECT customer_id, COUNT(DISTINCT currency) AS distinct_currency_count FROM financial_services.accounts GROUP BY customer_id HAVING COUNT(DISTINCT currency) > 1

[User] For these customers, also list the average balance across all their accounts.

[Assistant] SELECT customer_id, COUNT(DISTINCT currency) AS distinct_currency_count, AVG(balance) AS average_balance FROM financial_services.accounts GROUP BY customer_id HAVING COUNT(DISTINCT currency) > 1

[User] Sort the results by the number of distinct currencies in descending order.

[Assistant] SELECT customer_id, COUNT(DISTINCT currency) AS distinct_currency_count, AVG(balance) AS average_balance FROM financial_services.accounts GROUP BY customer_id HAVING COUNT(DISTINCT currency) > 1 ORDER BY distinct_currency_count DESC


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.customers ( customer_id.text, first_name.text, last_name.text, date_of_birth.date, ssn_hash.text, address.text, city.text, state.text, zip_code.text, country.text, email.text, phone_number.text, created_at.timestamp, status.text, risk_profile.text )
CREATE TABLE financial_services.transactions ( transaction_id.text, account_id.text, related_account_id.text, transaction_type.text, amount.numeric, currency.text, transaction_date.timestamp, effective_date.date, description.text, status.text, reference_number.text )
CREATE TABLE financial_services.securities ( security_id.text, ticker_symbol.text, isin_code.text, cusip_code.text, security_name.text, security_type.text, exchange.text, currency.text, issuer_name.text, sector.text, last_updated.timestamp )
CREATE TABLE financial_services.trades ( trade_id.text, account_id.text, security_id.text, order_id.text, trade_type.text, quantity.numeric, price_per_unit.numeric, total_amount.numeric, commission.numeric, trade_timestamp.timestamp, settlement_date.date, status.text, execution_venue.text )
CREATE TABLE financial_services.market_data ( data_point_id.bigint, security_id.text, data_timestamp.timestamp, open_price.numeric, high_price.numeric, low_price.numeric, close_price.numeric, adjusted_close_price.numeric, volume.bigint, source.text )
CREATE TABLE financial_services.employees ( employee_id.text, first_name.text, last_name.text, job_title.text, department.text, branch_id.text, email.text, phone_extension.text, hire_date.date, termination_date.date, manager_id.text, status.text )
CREATE TABLE financial_services.loans ( loan_id.text, account_id.text, loan_type.text, principal_amount.numeric, current_principal_balance.numeric, interest_rate.numeric, term_months.integer, origination_date.date, maturity_date.date, monthly_payment.numeric, collateral_description.text, status.text )

[User] I need a report showing each security's ticker_symbol along with the total sum of trade total_amount and the count of trades executed in the last three months.

[Assistant]
SELECT s.ticker_symbol, SUM(t.total_amount) AS total_trade_amount, COUNT(*) AS trade_count
FROM financial_services.trades t
JOIN financial_services.securities s ON t.security_id = s.security_id
WHERE t.trade_timestamp >= CURRENT_DATE - INTERVAL '3 months'
GROUP BY s.ticker_symbol;

[User] Actually, only include trades with status 'SETTLED'.

[Assistant]
SELECT s.ticker_symbol, SUM(t.total_amount) AS total_trade_amount, COUNT(*) AS trade_count
FROM financial_services.trades t
JOIN financial_services.securities s ON t.security_id = s.security_id
WHERE t.status = 'SETTLED'
  AND t.trade_timestamp >= CURRENT_DATE - INTERVAL '3 months'
GROUP BY s.ticker_symbol;

[User] Also, filter to securities listed on the 'NYSE' exchange and include the issuer_name.

[Assistant]
SELECT s.ticker_symbol, s.issuer_name, SUM(t.total_amount) AS total_trade_amount, COUNT(*) AS trade_count
FROM financial_services.trades t
JOIN financial_services.securities s ON t.security_id = s.security_id
WHERE t.status = 'SETTLED'
  AND t.trade_timestamp >= CURRENT_DATE - INTERVAL '3 months'
  AND s.exchange = 'NYSE'
GROUP BY s.ticker_symbol, s.issuer_name;

[User] One more thing: only show results where total_trade_amount exceeds 1000000, and order by total_trade_amount descending.

[Assistant]
SELECT s.ticker_symbol, s.issuer_name, SUM(t.total_amount) AS total_trade_amount, COUNT(*) AS trade_count
FROM financial_services.trades t
JOIN financial_services.securities s ON t.security_id = s.security_id
WHERE t.status = 'SETTLED'
  AND t.trade_timestamp >= CURRENT_DATE - INTERVAL '3 months'
  AND s.exchange = 'NYSE'
GROUP BY s.ticker_symbol, s.issuer_name
HAVING SUM(t.total_amount) > 1000000
ORDER BY total_trade_amount DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.securities ( security_id.text, ticker_symbol.text, isin_code.text, cusip_code.text, security_name.text, security_type.text, exchange.text, currency.text, issuer_name.text, sector.text, last_updated.timestamp )

[User] List pairs of securities from the same issuer where one security was updated within the last 30 days, and the other was updated more than 90 days ago. Show issuer name, ticker symbols, and last_updated timestamps for both.

[Assistant] SELECT a.issuer_name, a.ticker_symbol AS ticker_symbol_a, a.last_updated AS last_updated_a, b.ticker_symbol AS ticker_symbol_b, b.last_updated AS last_updated_b FROM financial_services.securities AS a JOIN financial_services.securities AS b ON a.issuer_name = b.issuer_name WHERE a.security_id != b.security_id AND a.last_updated >= CURRENT_DATE - INTERVAL '30 days' AND b.last_updated < CURRENT_DATE - INTERVAL '90 days';

[User] Only include issuers who have more than 5 securities in total.

[Assistant] WITH IssuerCounts AS (SELECT issuer_name, COUNT(*) AS total_securities FROM financial_services.securities WHERE issuer_name IS NOT NULL GROUP BY issuer_name HAVING COUNT(*) > 5) SELECT a.issuer_name, a.ticker_symbol AS ticker_symbol_a, a.last_updated AS last_updated_a, b.ticker_symbol AS ticker_symbol_b, b.last_updated AS last_updated_b FROM financial_services.securities AS a JOIN financial_services.securities AS b ON a.issuer_name = b.issuer_name JOIN IssuerCounts ic ON a.issuer_name = ic.issuer_name WHERE a.security_id != b.security_id AND a.last_updated >= CURRENT_DATE - INTERVAL '30 days' AND b.last_updated < CURRENT_DATE - INTERVAL '90 days';

[User] Order the results by issuer name, then by the more recently updated security's ticker symbol.

[Assistant] WITH IssuerCounts AS (SELECT issuer_name, COUNT(*) AS total_securities FROM financial_services.securities WHERE issuer_name IS NOT NULL GROUP BY issuer_name HAVING COUNT(*) > 5) SELECT a.issuer_name, a.ticker_symbol AS ticker_symbol_a, a.last_updated AS last_updated_a, b.ticker_symbol AS ticker_symbol_b, b.last_updated AS last_updated_b FROM financial_services.securities AS a JOIN financial_services.securities AS b ON a.issuer_name = b.issuer_name JOIN IssuerCounts ic ON a.issuer_name = ic.issuer_name WHERE a.security_id != b.security_id AND a.last_updated >= CURRENT_DATE - INTERVAL '30 days' AND b.last_updated < CURRENT_DATE - INTERVAL '90 days' ORDER BY a.issuer_name ASC, a.ticker_symbol ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.clients ( client_id text, first_name text, last_name text, company_name text, email text, phone text, address text, date_registered timestamp, status text )
CREATE TABLE legal_services.lawyers ( lawyer_id text, first_name text, last_name text, bar_number text, firm_id text, email text, phone text, specialization text, hire_date timestamp, is_partner boolean )
CREATE TABLE legal_services.law_firms ( firm_id text, firm_name text, address text, phone text, website text, founded_date date, managing_partner_id text )
CREATE TABLE legal_services.documents ( document_id text, case_id text, document_name text, document_type text, storage_path text, uploaded_by_lawyer_id text, upload_timestamp timestamp, version integer, description text )
CREATE TABLE legal_services.time_entries ( entry_id text, case_id text, lawyer_id text, date_worked date, hours_spent numeric, billing_rate numeric, description text, is_billable boolean, is_billed boolean, invoice_id text, created_at timestamp )
CREATE TABLE legal_services.appointments ( appointment_id text, client_id text, lawyer_id text, case_id text, start_time timestamp, end_time timestamp, location text, subject text, notes text, status text, created_at timestamp )

[User] Show me all time entries where the hours spent is greater than 5.

[Assistant] SELECT entry_id, date_worked, hours_spent, description FROM legal_services.time_entries WHERE hours_spent > 5;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.clients ( client_id text PRIMARY KEY, first_name text, last_name text, company_name text, email text UNIQUE, phone text, address text, date_registered timestamp, status text )
CREATE TABLE legal_services.lawyers ( lawyer_id.text, first_name.text, last_name.text, bar_number.text, firm_id.text, email.text, phone.text, specialization.text, hire_date.timestamp, is_partner.boolean )
CREATE TABLE legal_services.cases (
    case_id character varying(64) NOT NULL,  -- unique identifier for the case/matter
    case_number character varying(100) UNIQUE, -- official case number (court or internal)
    case_name text NOT NULL, -- descriptive name or title for the case
    client_id character varying(64) NOT NULL, -- FK to clients table
    lead_lawyer_id character varying(64) NOT NULL, -- FK to lawyers table (primary lawyer responsible)
    case_type character varying(100) NOT NULL, -- e.g., Litigation, Corporate, Family Law, IP
    status character varying(50) NOT NULL, -- e.g., Open, Closed, Pending, On Hold, Appealed
    date_opened timestamp NOT NULL, -- date the case was formally opened
    date_closed timestamp, -- date the case was closed (nullable)
    description text, -- detailed description of the case
    court_jurisdiction character varying(128), -- court or jurisdiction if applicable
    PRIMARY KEY (case_id)
)
CREATE TABLE legal_services.invoices ( invoice_id text, invoice_number text, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )

[User] List each partner lawyer's first_name, last_name along with the count of invoices for the cases they lead.

[Assistant]
SELECT l.lawyer_id, l.first_name, l.last_name, COUNT(i.invoice_id) AS invoice_count
FROM legal_services.lawyers l
JOIN legal_services.cases c ON l.lawyer_id = c.lead_lawyer_id
JOIN legal_services.invoices i ON c.case_id = i.case_id
WHERE l.is_partner = TRUE
GROUP BY l.lawyer_id, l.first_name, l.last_name;

[User] Only include those partners who have more than 3 invoices.

[Assistant]
SELECT l.lawyer_id, l.first_name, l.last_name, COUNT(i.invoice_id) AS invoice_count
FROM legal_services.lawyers l
JOIN legal_services.cases c ON l.lawyer_id = c.lead_lawyer_id
JOIN legal_services.invoices i ON c.case_id = i.case_id
WHERE l.is_partner = TRUE
GROUP BY l.lawyer_id, l.first_name, l.last_name
HAVING COUNT(i.invoice_id) > 3;

[User] Also restrict to invoices issued after '2024-01-01'.

[Assistant]
SELECT l.lawyer_id, l.first_name, l.last_name, COUNT(i.invoice_id) AS invoice_count
FROM legal_services.lawyers l
JOIN legal_services.cases c ON l.lawyer_id = c.lead_lawyer_id
JOIN legal_services.invoices i ON c.case_id = i.case_id
WHERE l.is_partner = TRUE
  AND i.issue_date > '2024-01-01'
GROUP BY l.lawyer_id, l.first_name, l.last_name
HAVING COUNT(i.invoice_id) > 3;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.lawyers ( lawyer_id.text, first_name.text, last_name.text, bar_number.text, firm_id.text, email.text, phone.text, specialization.text, hire_date.timestamp, is_partner.boolean )
CREATE TABLE legal_services.law_firms ( firm_id.text, firm_name.text, address.text, phone.text, website.text, founded_date.date, managing_partner_id.text )
CREATE TABLE legal_services.cases ( case_id.text, case_number.text, case_name.text, client_id.text, lead_lawyer_id.text, case_type.text, status.text, date_opened.timestamp, date_closed.timestamp, description.text, court_jurisdiction.text )
CREATE TABLE legal_services.time_entries ( entry_id.text, case_id.text, lawyer_id.text, date_worked.date, hours_spent.numeric, billing_rate.numeric, description.text, is_billable.boolean, is_billed.boolean, invoice_id.text, created_at.timestamp )
CREATE TABLE legal_services.appointments ( appointment_id.text, client_id.text, lawyer_id.text, case_id.text, start_time.timestamp, end_time.timestamp, location.text, subject.text, notes.text, status.text, created_at.timestamp )

[User] Show me the names of all law firms and the total number of lawyers associated with each firm.

[Assistant] SELECT T1.firm_name, count(T2.lawyer_id) FROM legal_services.law_firms AS T1 JOIN legal_services.lawyers AS T2 ON T1.firm_id = T2.firm_id GROUP BY T1.firm_id, T1.firm_name


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.clients ( client_id text, first_name text, last_name text, company_name text, email text, phone text, address text, date_registered timestamp, status text )
CREATE TABLE legal_services.lawyers ( lawyer_id.text, first_name.text, last_name.text, bar_number.text, firm_id.text, email.text, phone.text, specialization.text, hire_date.timestamp, is_partner.boolean )
CREATE TABLE legal_services.law_firms ( firm_id character varying(64) NOT NULL, firm_name character varying(200) NOT NULL, address text NOT NULL, phone character varying(32), website character varying(255), founded_date date, managing_partner_id character varying(64), PRIMARY KEY (firm_id) )
CREATE TABLE legal_services.cases ( case_id.text, case_number.text, case_name.text, client_id.text, lead_lawyer_id.text, case_type.text, status.text, date_opened.timestamp, date_closed.timestamp, description.text, court_jurisdiction.text )
CREATE TABLE legal_services.documents ( document_id.text, case_id.text, document_name.text, document_type.text, storage_path.text, uploaded_by_lawyer_id.text, upload_timestamp.timestamp, version.integer, description.text )
CREATE TABLE legal_services.invoices ( invoice_id text, invoice_number text, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )

[User] List each client's first and last name along with the number of cases they have, alias the count as case_count.

[Assistant]
SELECT cl.first_name, cl.last_name, COUNT(c.case_id) AS case_count
FROM legal_services.clients cl
LEFT JOIN legal_services.cases c ON cl.client_id = c.client_id
GROUP BY cl.client_id, cl.first_name, cl.last_name;

[User] Actually, only include clients who have more than 2 cases.

[Assistant]
SELECT cl.first_name, cl.last_name, COUNT(c.case_id) AS case_count
FROM legal_services.clients cl
LEFT JOIN legal_services.cases c ON cl.client_id = c.client_id
GROUP BY cl.client_id, cl.first_name, cl.last_name
HAVING COUNT(c.case_id) > 2;

[User] Also sort the results by case_count descending and then by the client's last_name ascending.

[Assistant]
SELECT cl.first_name, cl.last_name, COUNT(c.case_id) AS case_count
FROM legal_services.clients cl
LEFT JOIN legal_services.cases c ON cl.client_id = c.client_id
GROUP BY cl.client_id, cl.first_name, cl.last_name
HAVING COUNT(c.case_id) > 2
ORDER BY case_count DESC, cl.last_name ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.law_firms ( firm_id.text, firm_name.text, address.text, phone.text, website.text, founded_date.date, managing_partner_id.text )

[User] List all law firms that do not have a website registered, including their firm name and phone.

[Assistant]
SELECT firm_name, phone
FROM legal_services.law_firms
WHERE website IS NULL OR website = '';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.time_entries ( entry_id text, case_id text, lawyer_id text, date_worked date, hours_spent numeric, billing_rate numeric, description text, is_billable boolean, is_billed boolean, invoice_id text, created_at timestamp )
CREATE TABLE legal_services.invoices ( invoice_id text, invoice_number text, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )
CREATE TABLE legal_services.appointments ( appointment_id text, client_id text, lawyer_id text, case_id text, start_time timestamp, end_time timestamp, location text, subject text, notes text, status text, created_at timestamp )

[User] List all invoices with a total_amount less than 1000 and show the associated client's ID and case ID.

[Assistant]
SELECT invoice_id, client_id, case_id, total_amount
FROM legal_services.invoices
WHERE total_amount < 1000;

[User] Actually, can you also include the invoice status and order the results by total_amount ascending?

[Assistant]
SELECT invoice_id, client_id, case_id, total_amount, status
FROM legal_services.invoices
WHERE total_amount < 1000
ORDER BY total_amount ASC;

[User] Now, only show invoices where the status is 'Sent' or 'Overdue', and include the issue_date as well.

[Assistant]
SELECT invoice_id, client_id, case_id, total_amount, status, issue_date
FROM legal_services.invoices
WHERE total_amount < 1000 AND status IN ('Sent', 'Overdue')
ORDER BY total_amount ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.invoices ( invoice_id text PRIMARY KEY, invoice_number text UNIQUE, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )

[User] Show me each invoice and the invoice_number of the next invoice for the same client, along with how many days apart their issue_dates are.

[Assistant]
SELECT a.invoice_number AS invoice_number,
       b.invoice_number AS next_invoice_number,
       (b.issue_date - a.issue_date) AS days_between
  FROM legal_services.invoices a
  JOIN legal_services.invoices b
    ON a.client_id = b.client_id
   AND b.issue_date > a.issue_date;

[User] Please restrict to pairs where the days_between is greater than 30.

[Assistant]
SELECT a.invoice_number AS invoice_number,
       b.invoice_number AS next_invoice_number,
       (b.issue_date - a.issue_date) AS days_between
  FROM legal_services.invoices a
  JOIN legal_services.invoices b
    ON a.client_id = b.client_id
   AND b.issue_date > a.issue_date
 WHERE (b.issue_date - a.issue_date) > 30;

[User] And only include pairs where both invoices have status 'Overdue'.

[Assistant]
SELECT a.invoice_number AS invoice_number,
       b.invoice_number AS next_invoice_number,
       (b.issue_date - a.issue_date) AS days_between
  FROM legal_services.invoices a
  JOIN legal_services.invoices b
    ON a.client_id = b.client_id
   AND b.issue_date > a.issue_date
 WHERE (b.issue_date - a.issue_date) > 30
   AND a.status = 'Overdue'
   AND b.status = 'Overdue';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.time_entries ( entry_id text PRIMARY KEY, case_id text, lawyer_id text, date_worked date, hours_spent numeric, billing_rate numeric, description text, is_billable bool, is_billed bool, invoice_id text, created_at timestamp )

[User] Show me all time entries for case ID 'case_abc', including the entry ID, date worked, hours spent, and the first and last name of the lawyer.

[Assistant] SELECT te.entry_id, te.date_worked, te.hours_spent, l.first_name, l.last_name FROM legal_services.time_entries AS te JOIN legal_services.lawyers AS l ON te.lawyer_id = l.lawyer_id WHERE te.case_id = 'case_abc';

[User] Okay, now only show the entries that are marked as billable.

[Assistant] SELECT te.entry_id, te.date_worked, te.hours_spent, l.first_name, l.last_name FROM legal_services.time_entries AS te JOIN legal_services.lawyers AS l ON te.lawyer_id = l.lawyer_id WHERE te.case_id = 'case_abc' AND te.is_billable = TRUE;

[User] Also, include the description for these entries and sort them by date worked, oldest first.

[Assistant] SELECT te.entry_id, te.date_worked, te.hours_spent, l.first_name, l.last_name, te.description FROM legal_services.time_entries AS te JOIN legal_services.lawyers AS l ON te.lawyer_id = l.lawyer_id WHERE te.case_id = 'case_abc' AND te.is_billable = TRUE ORDER BY te.date_worked ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.clients ( client_id text PRIMARY KEY, first_name text, last_name text, company_name text, email text UNIQUE, phone text, address text, date_registered timestamp, status text )
CREATE TABLE legal_services.lawyers (
    lawyer_id character varying(64) NOT NULL,  -- unique identifier for the lawyer
    first_name character varying(100) NOT NULL, -- lawyer's first name
    last_name character varying(100) NOT NULL, -- lawyer's last name
    bar_number character varying(64) UNIQUE NOT NULL, -- lawyer's bar association number
    firm_id character varying(64), -- FK to law_firms table
    email character varying(128) UNIQUE NOT NULL, -- lawyer's professional email
    phone character varying(32), -- lawyer's contact phone number
    specialization text, -- areas of legal expertise
    hire_date timestamp NOT NULL, -- date the lawyer was hired or joined
    is_partner boolean DEFAULT false, -- flag indicating if the lawyer is a partner
    PRIMARY KEY (lawyer_id)
)
CREATE TABLE legal_services.law_firms ( firm_id text PRIMARY KEY, firm_name text, address text, phone text, website text, founded_date date, managing_partner_id text )
CREATE TABLE legal_services.cases ( case_id.text, case_number.text, case_name.text, client_id.text, lead_lawyer_id.text, case_type.text, status.text, date_opened.timestamp, date_closed.timestamp, description.text, court_jurisdiction.text )
CREATE TABLE legal_services.invoices ( invoice_id.text, invoice_number.text, client_id.text, case_id.text, issue_date.date, due_date.date, total_amount.numeric, amount_paid.numeric, status.text, payment_date.timestamp, notes.text, created_at.timestamp )
CREATE TABLE legal_services.appointments (
    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment
    client_id character varying(64) NOT NULL, -- FK to clients table
    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table
    case_id character varying(64), -- FK to cases table (optional, if related to a specific case)
    start_time timestamp NOT NULL, -- scheduled start date and time
    end_time timestamp NOT NULL, -- scheduled end date and time
    location text, -- location of the meeting (address or virtual link)
    subject character varying(255), -- subject or purpose of the appointment
    notes text, -- additional notes for the appointment
    status character varying(50) NOT NULL, -- e.g., Scheduled, Completed, Canceled, Rescheduled
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (appointment_id)
)

[User] List all cases where the client and the lead lawyer belong to companies or law firms with the same phone number. For each such case, please show the case name, client name, client company, lead lawyer name, and the shared phone number.

[Assistant]
SELECT cases.case_name, c.first_name AS client_first_name, c.last_name AS client_last_name, c.company_name, l.first_name AS lawyer_first_name, l.last_name AS lawyer_last_name, f.phone AS shared_phone
FROM legal_services.cases
JOIN legal_services.clients c ON cases.client_id = c.client_id
JOIN legal_services.lawyers l ON cases.lead_lawyer_id = l.lawyer_id
JOIN legal_services.law_firms f ON l.firm_id = f.firm_id
WHERE c.phone = f.phone;

[User] Can you include the case number and sort the results by the shared phone number?

[Assistant]
SELECT cases.case_number, cases.case_name, c.first_name AS client_first_name, c.last_name AS client_last_name, c.company_name, l.first_name AS lawyer_first_name, l.last_name AS lawyer_last_name, f.phone AS shared_phone
FROM legal_services.cases
JOIN legal_services.clients c ON cases.client_id = c.client_id
JOIN legal_services.lawyers l ON cases.lead_lawyer_id = l.lawyer_id
JOIN legal_services.law_firms f ON l.firm_id = f.firm_id
WHERE c.phone = f.phone
ORDER BY f.phone;

[User] Actually, please only show cases where the shared phone number is not null and starts with '+44'.

[Assistant]
SELECT cases.case_number, cases.case_name, c.first_name AS client_first_name, c.last_name AS client_last_name, c.company_name, l.first_name AS lawyer_first_name, l.last_name AS lawyer_last_name, f.phone AS shared_phone
FROM legal_services.cases
JOIN legal_services.clients c ON cases.client_id = c.client_id
JOIN legal_services.lawyers l ON cases.lead_lawyer_id = l.lawyer_id
JOIN legal_services.law_firms f ON l.firm_id = f.firm_id
WHERE c.phone = f.phone AND f.phone IS NOT NULL AND f.phone LIKE '+44%'
ORDER BY f.phone;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.invoices ( invoice_id.text, invoice_number.text, client_id.text, case_id.text, issue_date.date, due_date.date, total_amount.numeric, amount_paid.numeric, status.text, payment_date.timestamp, notes.text, created_at.timestamp )

[User] I want to find all pairs of invoices belonging to the same client. Show me the client_id, the invoice_number for the earlier invoice and the invoice_number for the later invoice.

[Assistant]
SELECT i1.client_id,
       i1.invoice_number AS earlier_invoice,
       i2.invoice_number AS later_invoice
FROM legal_services.invoices i1
JOIN legal_services.invoices i2
  ON i1.client_id = i2.client_id
 AND i1.issue_date < i2.issue_date;

[User] Actually, only include pairs where the difference between the two issue dates is no more than 7 days.

[Assistant]
SELECT i1.client_id,
       i1.invoice_number AS earlier_invoice,
       i2.invoice_number AS later_invoice
FROM legal_services.invoices i1
JOIN legal_services.invoices i2
  ON i1.client_id = i2.client_id
 AND i1.issue_date < i2.issue_date
 AND i2.issue_date - i1.issue_date <= INTERVAL '7 days';

[User] Also, only keep pairs where both invoices are unpaid (amount_paid < total_amount).

[Assistant]
SELECT i1.client_id,
       i1.invoice_number AS earlier_invoice,
       i2.invoice_number AS later_invoice
FROM legal_services.invoices i1
JOIN legal_services.invoices i2
  ON i1.client_id = i2.client_id
 AND i1.issue_date < i2.issue_date
 AND i2.issue_date - i1.issue_date <= INTERVAL '7 days'
WHERE i1.amount_paid < i1.total_amount
  AND i2.amount_paid < i2.total_amount;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.wallets ( wallet_id.text, user_id.text, address.text, private_key.text, created_at.timestamp )

[User] For each user, show their user ID and the count of unique wallet addresses they own.

[Assistant] SELECT user_id, COUNT(DISTINCT address) FROM wallets GROUP BY user_id;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.users ( user_id text PRIMARY KEY, username text, email text, password_hash text, created_at timestamp )
CREATE TABLE trading_platform.assets (
    asset_id character varying(64) NOT NULL,  -- unique identifier for the asset
    name character varying(128) NOT NULL, -- name of the asset
    symbol character varying(32) NOT NULL, -- symbol of the asset
    type character varying(32) NOT NULL, -- type of the asset (e.g., cryptocurrency, stock)
    PRIMARY KEY (asset_id)
)
CREATE TABLE trading_platform.dapps ( dapp_id.text, name.text, description.text, url.text )
CREATE TABLE trading_platform.peers ( peer_id character varying(64) NOT NULL, ip_address character varying(15) NOT NULL, port integer NOT NULL, last_seen timestamp NOT NULL, PRIMARY KEY (peer_id) )
CREATE TABLE trading_platform.metadata (
    metadata_id character varying(64) NOT NULL,  -- unique identifier for the metadata
    asset_id character varying(64) NOT NULL, -- identifier of the asset the metadata is associated with
    key character varying(128) NOT NULL, -- key of the metadata
    value text NOT NULL, -- value of the metadata
    PRIMARY KEY (metadata_id)
)
CREATE TABLE trading_platform.kyc_audit ( kyc_audit_id.text, user_id.text, status.text, reviewed_at.timestamp )
CREATE TABLE trading_platform.logs (
    log_id character varying(64) NOT NULL,  -- unique identifier for the log entry
    user_id character varying(64), -- identifier of the user associated with the log entry
    action character varying(128) NOT NULL, -- action performed
    details text NOT NULL, -- details of the action
    logged_at timestamp NOT NULL, -- time when the log entry was created
    PRIMARY KEY (log_id)
)
CREATE TABLE trading_platform.notifications ( notification_id.text, user_id.text, message.text, sent_at.timestamp, read_at.timestamp )

[User] Show the username and the total number of log entries for each user who has logged any action.

[Assistant] SELECT T1.username, COUNT(T2.log_id) FROM users AS T1 JOIN logs AS T2 ON T1.user_id = T2.user_id GROUP BY T1.username;

[User] Refine this to only include users whose log entries contain the word 'error' and who have more than 5 such log entries.

[Assistant] SELECT T1.username, COUNT(T2.log_id) FROM users AS T1 JOIN logs AS T2 ON T1.user_id = T2.user_id WHERE T2.details LIKE '%error%' GROUP BY T1.username HAVING COUNT(T2.log_id) > 5;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.wallets ( wallet_id.text, user_id.text, address.text, private_key.text, created_at.timestamp )
CREATE TABLE trading_platform.dapps ( dapp_id.text, name.text, description.text, url.text )
CREATE TABLE trading_platform.kyc_audit ( kyc_audit_id.text, user_id.text, status.text, reviewed_at.timestamp )
CREATE TABLE trading_platform.logs ( log_id.text, user_id.text, action.text, details.text, logged_at.timestamp )

[User] Give me a count of log entries for each user.

[Assistant]
SELECT user_id, COUNT(*) AS log_count
FROM trading_platform.logs
GROUP BY user_id;

[User] Only show users who have more than 10 log entries.

[Assistant]
SELECT user_id, COUNT(*) AS log_count
FROM trading_platform.logs
GROUP BY user_id
HAVING COUNT(*) > 10;

[User] Please include their wallet addresses as well.

[Assistant]
SELECT l.user_id, w.address, COUNT(*) AS log_count
FROM trading_platform.logs l
JOIN trading_platform.wallets w ON l.user_id = w.user_id
GROUP BY l.user_id, w.address
HAVING COUNT(*) > 10;

[User] If a user has multiple wallets, show each in a separate row.

[Assistant]
SELECT l.user_id, w.address, COUNT(*) AS log_count
FROM trading_platform.logs l
JOIN trading_platform.wallets w ON l.user_id = w.user_id
GROUP BY l.user_id, w.address
HAVING COUNT(*) > 10;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )
CREATE TABLE trading_platform.orders ( order_id text, user_id text, wallet_id text, asset_id text, order_type text, quantity numeric, price numeric, status text, created_at timestamp )
CREATE TABLE trading_platform.trades ( trade_id text, order_id text, buyer_id text, seller_id text, asset_id text, quantity numeric, price numeric, traded_at timestamp )
CREATE TABLE trading_platform.assets ( asset_id text, name text, symbol text, type text )
CREATE TABLE trading_platform.dapps ( dapp_id text, name text, description text, url text )
CREATE TABLE trading_platform.peers ( peer_id text, ip_address text, port integer, last_seen timestamp )
CREATE TABLE trading_platform.metadata ( metadata_id text, asset_id text, key text, value text )
CREATE TABLE trading_platform.kyc_audit ( kyc_audit_id text, user_id text, status text, reviewed_at timestamp )
CREATE TABLE trading_platform.logs ( log_id text, user_id text, action text, details text, logged_at timestamp )

[User] List user IDs with approved KYC status and the addresses of their wallets.

[Assistant] SELECT DISTINCT w.user_id, w.address FROM trading_platform.wallets w JOIN trading_platform.kyc_audit k ON w.user_id = k.user_id WHERE k.status = 'approved';

[User] From that list, also show the total number of unspent UTXOs associated with each wallet address.

[Assistant] SELECT w.user_id, w.address, COUNT(u.utxo_id) AS unspent_utxo_count FROM trading_platform.wallets w JOIN trading_platform.kyc_audit k ON w.user_id = k.user_id JOIN trading_platform.utxos u ON w.address = u.address WHERE k.status = 'approved' AND u.spent = FALSE GROUP BY w.user_id, w.address;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.users ( user_id.text, username.text, email.text, password_hash.text, created_at.timestamp )
CREATE TABLE trading_platform.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )
CREATE TABLE trading_platform.orders ( order_id text, user_id text, wallet_id text, asset_id text, order_type text, quantity numeric, price numeric, status text, created_at timestamp )
CREATE TABLE trading_platform.trades ( trade_id character varying(64) NOT NULL, order_id character varying(64) NOT NULL, buyer_id character varying(64) NOT NULL, seller_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, quantity numeric(38,14) NOT NULL, price numeric(38,14) NOT NULL, traded_at timestamp NOT NULL, PRIMARY KEY (trade_id) )
CREATE TABLE trading_platform.assets ( asset_id text, name text, symbol text, type text )
CREATE TABLE trading_platform.dapps ( dapp_id text, name text, description text, url text )
CREATE TABLE trading_platform.peers ( peer_id.text, ip_address.text, port.integer, last_seen.timestamp )
CREATE TABLE trading_platform.metadata ( metadata_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, key character varying(128) NOT NULL, value text NOT NULL, PRIMARY KEY (metadata_id) )
CREATE TABLE trading_platform.kyc_audit ( kyc_audit_id.text, user_id.text, status.text, reviewed_at.timestamp )
CREATE TABLE trading_platform.logs ( log_id text PRIMARY KEY, user_id text, action text, details text, logged_at timestamp )
CREATE TABLE trading_platform.notifications ( notification_id text, user_id text, message text, sent_at timestamp, read_at timestamp )

[User] List all unique actions that have been logged in the system.

[Assistant] SELECT DISTINCT action FROM trading_platform.logs;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.users ( user_id.text, username.text, email.text, password_hash.text, created_at.timestamp )
CREATE TABLE trading_platform.orders ( order_id text, user_id text, wallet_id text, asset_id text, order_type text, quantity numeric, price numeric, status text, created_at timestamp )
CREATE TABLE trading_platform.assets ( asset_id text, name text, symbol text, type text )
CREATE TABLE trading_platform.dapps ( dapp_id text, name text, description text, url text )
CREATE TABLE trading_platform.peers ( peer_id.text, ip_address.text, port.integer, last_seen.timestamp )
CREATE TABLE trading_platform.metadata ( metadata_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, key character varying(128) NOT NULL, value text NOT NULL, PRIMARY KEY (metadata_id) )
CREATE TABLE trading_platform.logs ( log_id text PRIMARY KEY, user_id text, action text, details text, logged_at timestamp )
CREATE TABLE trading_platform.notifications ( notification_id text, user_id text, message text, sent_at timestamp, read_at timestamp )

[User] List all DApps along with the number of metadata entries linked to each, even if the DApp has no linked metadata.

[Assistant]
SELECT d.name, d.url, COUNT(m.metadata_id) AS metadata_count
FROM trading_platform.dapps d
LEFT JOIN trading_platform.metadata m ON d.dapp_id = m.asset_id
GROUP BY d.dapp_id, d.name, d.url;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )
CREATE TABLE trading_platform.trades ( trade_id text, order_id text, buyer_id text, seller_id text, asset_id text, quantity numeric, price numeric, traded_at timestamp )
CREATE TABLE trading_platform.assets ( asset_id text, name text, symbol text, type text )
CREATE TABLE trading_platform.utxos ( utxo_id text, transaction_id text, output_index integer, address text, amount numeric, spent boolean )
CREATE TABLE trading_platform.peers ( peer_id text, ip_address text, port integer, last_seen timestamp )
CREATE TABLE trading_platform.metadata ( metadata_id text, asset_id text, key text, value text )
CREATE TABLE trading_platform.kyc_audit ( kyc_audit_id text, user_id text, status text, reviewed_at timestamp )

[User] I want a summary of each asset showing the total number of trades executed and the average trade price, including asset name and symbol.

[Assistant]
SELECT a.asset_id,
       a.name,
       a.symbol,
       COUNT(t.trade_id) AS trades_count,
       AVG(t.price) AS avg_price
FROM trading_platform.assets a
LEFT JOIN trading_platform.trades t ON a.asset_id = t.asset_id
GROUP BY a.asset_id, a.name, a.symbol;

[User] Actually, exclude trades before '2024-05-01'.

[Assistant]
SELECT a.asset_id,
       a.name,
       a.symbol,
       COUNT(t.trade_id) AS trades_count,
       AVG(t.price) AS avg_price
FROM trading_platform.assets a
LEFT JOIN trading_platform.trades t ON a.asset_id = t.asset_id
  AND t.traded_at >= '2024-05-01'
GROUP BY a.asset_id, a.name, a.symbol;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.orders ( order_id text PRIMARY KEY, user_id text, wallet_id text, asset_id text, order_type text, quantity numeric, price numeric, status text, created_at timestamp )
CREATE TABLE trading_platform.assets ( asset_id character varying(64) NOT NULL, name character varying(128) NOT NULL, symbol character varying(32) NOT NULL, type character varying(32) NOT NULL, PRIMARY KEY (asset_id) )
CREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )
CREATE TABLE trading_platform.dapps ( dapp_id character varying(64) NOT NULL, name character varying(128) NOT NULL, description text NOT NULL, url character varying(256) NOT NULL, PRIMARY KEY (dapp_id) )
CREATE TABLE trading_platform.peers ( peer_id.text, ip_address.text, port.integer, last_seen.timestamp )
CREATE TABLE trading_platform.metadata ( metadata_id text PRIMARY KEY, asset_id text, key text, value text )
CREATE TABLE trading_platform.logs ( log_id text PRIMARY KEY, user_id text, action text, details text, logged_at timestamp )
CREATE TABLE trading_platform.notifications ( notification_id.text, user_id.text, message.text, sent_at.timestamp, read_at.timestamp )

[User] Show me the total count and sum of amounts for spent and unspent UTXOs for each asset, including the asset name and symbol.

[Assistant]
SELECT a.asset_id, a.name AS asset_name, a.symbol, u.spent, COUNT(*) AS utxo_count, SUM(u.amount) AS total_amount
FROM trading_platform.assets a
LEFT JOIN trading_platform.utxos u
  ON a.asset_id = u.transaction_id
GROUP BY a.asset_id, a.name, a.symbol, u.spent
ORDER BY a.asset_id, u.spent;

[User] I'd like to see only assets where the sum of amounts for spent UTXOs is at least 100. Also, show only the spent UTXOs.

[Assistant]
SELECT a.asset_id, a.name AS asset_name, a.symbol, SUM(u.amount) AS spent_total_amount
FROM trading_platform.assets a
JOIN trading_platform.utxos u ON a.asset_id = u.transaction_id
WHERE u.spent = true
GROUP BY a.asset_id, a.name, a.symbol
HAVING SUM(u.amount) >= 100
ORDER BY spent_total_amount DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.users ( user_id.text, username.text, email.text, password_hash.text, created_at.timestamp )

[User] Show the email address and the creation date for every user, ordered by their username alphabetically.

[Assistant] SELECT email, created_at FROM trading_platform.users ORDER BY username ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.notifications ( notification_id text, user_id text, message text, sent_at timestamp, read_at timestamp )

[User] Show me all notifications sent in the last 7 days, including the user ID and message.

[Assistant] SELECT user_id, message, sent_at FROM trading_platform.notifications WHERE sent_at >= NOW() - INTERVAL '7 days';

[User] From that list, only show the notifications that have not been read yet.

[Assistant] SELECT user_id, message, sent_at FROM trading_platform.notifications WHERE sent_at >= NOW() - INTERVAL '7 days' AND read_at IS NULL;

[User] Instead of listing them, can you just give me the total count of unread notifications sent in the last 7 days?

[Assistant] SELECT COUNT(*) FROM trading_platform.notifications WHERE sent_at >= NOW() - INTERVAL '7 days' AND read_at IS NULL;

[User] Now, show the count of unread notifications sent in the last 7 days for each user ID.

[Assistant] SELECT user_id, COUNT(*) FROM trading_platform.notifications WHERE sent_at >= NOW() - INTERVAL '7 days' AND read_at IS NULL GROUP BY user_id;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE erc1155_approval_for_all ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash text, log_index integer, contract_address text )
CREATE TABLE erc20_balances ( block_number bigint, contract_address text, wallet_address text, amount text, pk text )
CREATE TABLE erc20_balances_historical ( block_number bigint, contract_address text, wallet_address text, amount text, pk integer )
CREATE TABLE nft_holders ( block_number bigint, contract_address text, wallet_address text, token_id text, contract_type text, amount text, pk text )
CREATE TABLE sui_coins ( object_id text, status text, coin_type text, balance text, owner text )
CREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )
CREATE TABLE nft_metadata ( blockchain text, contract_address text, token_id text, contract_name text, erc_type text, amount bigint, minter text, owner text, mint_block_number bigint, mint_time bigint, mint_transaction_hash text, mint_price text, token_uri text, metadata text, name text, image_uri text, traits text, updated_at bigint, status text, rarity_score real, rarity_rank integer, unique_attribute_count integer, pk integer )
CREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )
CREATE TABLE token_prices_latest ( blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )
CREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )
CREATE TABLE token_info ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, tick text, max_supply decimal, lim decimal, wlim decimal, dec integer, creator text )
CREATE TABLE mud_holesky_redstone ( address text, table_id text, key_bytes text, key0 text, key1 text, static_data text, encoded_lengths text, dynamic_data text, is_deleted boolean, block_number bigint, log_index bigint )
CREATE TABLE token_info_avalanche ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, tick text, max_supply decimal, lim decimal, wlim decimal, dec integer, creator text, minted decimal, holders decimal, txs decimal, updated_timestamp timestamp, completed_timestamp timestamp, id text )

[User] Show me all wallet addresses that hold more than 3 different NFTs from any ERC1155 contract. For each wallet, list the contract address and the count of distinct token_ids.

[Assistant]
SELECT contract_address, wallet_address, COUNT(DISTINCT token_id) AS token_id_count
FROM nft_holders
WHERE contract_type = 'ERC1155'
GROUP BY contract_address, wallet_address
HAVING COUNT(DISTINCT token_id) > 3;

[User] Can you also tell me the total amount of NFTs held by each of these wallets for the contracts they qualify for?

[Assistant]
SELECT contract_address, wallet_address, COUNT(DISTINCT token_id) AS token_id_count, SUM(CAST(amount AS numeric)) AS total_amount
FROM nft_holders
WHERE contract_type = 'ERC1155'
GROUP BY contract_address, wallet_address
HAVING COUNT(DISTINCT token_id) > 3;

[User] Actually, only include results for contracts where the total number of NFTs held by all wallets is over 1000. Show the contract address in the output.

[Assistant]
WITH contract_totals AS (
  SELECT contract_address, SUM(CAST(amount AS numeric)) AS contract_total_amount
  FROM nft_holders
  WHERE contract_type = 'ERC1155'
  GROUP BY contract_address
  HAVING SUM(CAST(amount AS numeric)) > 1000
)
SELECT n.contract_address, n.wallet_address, COUNT(DISTINCT n.token_id) AS token_id_count, SUM(CAST(n.amount AS numeric)) AS total_amount
FROM nft_holders n
JOIN contract_totals c ON n.contract_address = c.contract_address
WHERE n.contract_type = 'ERC1155'
GROUP BY n.contract_address, n.wallet_address
HAVING COUNT(DISTINCT n.token_id) > 3;

[User] Also include the name of the NFT for each token_id if available from nft_metadata. Only show NFTs on the Ethereum blockchain.

[Assistant]
WITH contract_totals AS (
  SELECT contract_address, SUM(CAST(amount AS numeric)) AS contract_total_amount
  FROM nft_holders
  WHERE contract_type = 'ERC1155'
  GROUP BY contract_address
  HAVING SUM(CAST(amount AS numeric)) > 1000
),
wallet_tokens AS (
  SELECT n.contract_address, n.wallet_address, n.token_id, SUM(CAST(n.amount AS numeric)) AS amount
  FROM nft_holders n
  JOIN contract_totals c ON n.contract_address = c.contract_address
  WHERE n.contract_type = 'ERC1155'
  GROUP BY n.contract_address, n.wallet_address, n.token_id
)
SELECT w.contract_address, w.wallet_address, w.token_id, w.amount, m.name AS nft_name
FROM wallet_tokens w
LEFT JOIN nft_metadata m
  ON m.blockchain = 'Ethereum' AND m.contract_address = w.contract_address AND m.token_id = w.token_id
WHERE w.amount > 0;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE token_metas ( block_timestamp.timestamp, block_number.bigint, transaction_hash.text, transaction_index.bigint, from_address.text, contract_address.text, symbol.text, total_supply.text, name.text, decimals.bigint, is_erc20.integer, is_erc721.integer, is_erc1155.integer, is_proxy.integer, extra_info.text, pk.integer )
CREATE TABLE erc1155_approval_for_all ( block_number.bigint, block_timestamp.timestamp, transaction_index.integer, transaction_hash.text, log_index.integer, contract_address.text )
CREATE TABLE erc20_balances_historical ( block_number.bigint, contract_address.text, wallet_address.text, amount.text, pk.integer )
CREATE TABLE nft_holders ( block_number.bigint, contract_address.text, wallet_address.text, token_id.text, contract_type.text, amount.text, pk.text )
CREATE TABLE nft_holder_historical ( block_number.bigint, contract_address.text, wallet_address.text, token_id.text, contract_type.text, amount.text, pk.integer )
CREATE TABLE sui_coins ( object_id.text, status.text, coin_type.text, balance.text, owner.text )
CREATE TABLE sui_coins_metadata ( object_id.text, coin_type.text, status.text, decimals.bigint, description.text, icon_url.text, symbol.text, name.text )
CREATE TABLE sui_nfts ( object_id.text, status.text, collection_type.text, package_id.text, previous_transaction.text, display.text, owner.text, name.text )
CREATE TABLE nft_metadata ( blockchain.text, contract_address.text, token_id.text, contract_name.text, erc_type.text, amount.bigint, minter.text, owner.text, mint_block_number.bigint, mint_time.bigint, mint_transaction_hash.text, mint_price.text, token_uri.text, metadata.text, name.text, image_uri.text, traits.text, updated_at.bigint, status.text, rarity_score.real, rarity_rank.integer, unique_attribute_count.integer, pk.integer )
CREATE TABLE nft_collections ( blockchain.text, contract_address.text, name.text, symbol.text, deploy_block_number.bigint, deploy_block_time.bigint, erc_type.text, owner.text, traits.text, description.text, slug.text, media_info.text, image_url.text, banner_image_url.text, updated_at.bigint, banner.text, token_count.bigint, floor_price.text, floor_price_symbol.text, floor_price_contract.text, pk.integer )
CREATE TABLE token_prices_latest ( blockchain.text, address.text, decimals.bigint, symbol.text, price.real, timestamp.timestamp )
CREATE TABLE token_balances ( block_number.bigint, block_timestamp.timestamp, tick.text, wallet_address.text, total_supply.decimal, amount.decimal )
CREATE TABLE token_info ( block_timestamp.timestamp, block_number.bigint, tx_index.integer, tx_hash.text, tick.text, max_supply.decimal, lim.decimal, wlim.decimal, dec.integer, creator.text )
CREATE TABLE token_activities ( block_timestamp.timestamp, block_number.bigint, tx_index.integer, tx_hash.text, log_index.integer, type.text, tick.text, id.text, amt.decimal, from_address.text, to_address.text )
CREATE TABLE mud_holesky_redstone ( address.text, table_id.text, key_bytes.text, key0.text, key1.text, static_data.text, encoded_lengths.text, dynamic_data.text, is_deleted.boolean, block_number.bigint, log_index.bigint )
CREATE TABLE token_balances_bitcoin ( block_number.bigint, block_timestamp.timestamp, tick.text, wallet_address.text, total_supply.text, amount.text )
CREATE TABLE token_activities_bitcoin ( block_timestamp.timestamp, block_number.bigint, tx_index.integer, tx_hash.text, log_index.integer, type.text, tick.text, id.text, amt.decimal, from_address.text, to_address.text )
CREATE TABLE token_activities_avalanche ( block_timestamp.timestamp, block_number.bigint, tx_index.integer, tx_hash.text, log_index.integer, type.text, tick.text, id.text, amt.decimal, from_address.text, to_address.text )
CREATE TABLE token_balances_avalanche ( block_number.bigint, block_timestamp.timestamp, tick.text, wallet_address.text, total_supply.decimal, amount.decimal )
CREATE TABLE token_info_avalanche ( block_timestamp.timestamp, block_number.bigint, tx_index.integer, tx_hash.text, tick.text, max_supply.decimal, lim.decimal, wlim.decimal, dec.integer, creator.text, minted.decimal, holders.decimal, txs.decimal, updated_timestamp.timestamp, completed_timestamp.timestamp, id.text )

[User] Show me the total amount held and number of unique wallets for each ERC20 token with a symbol ending in 'X'.

[Assistant] SELECT tm.symbol, SUM(CAST(ebh.amount AS DECIMAL)) AS total_amount, COUNT(DISTINCT ebh.wallet_address) AS unique_wallets FROM token_metas tm JOIN erc20_balances_historical ebh ON tm.contract_address = ebh.contract_address WHERE tm.is_erc20 = 1 AND tm.symbol LIKE '%X' GROUP BY tm.symbol;

[User] Can you also include the token name and the contract address in your results?

[Assistant] SELECT tm.symbol, tm.name, tm.contract_address, SUM(CAST(ebh.amount AS DECIMAL)) AS total_amount, COUNT(DISTINCT ebh.wallet_address) AS unique_wallets FROM token_metas tm JOIN erc20_balances_historical ebh ON tm.contract_address = ebh.contract_address WHERE tm.is_erc20 = 1 AND tm.symbol LIKE '%X' GROUP BY tm.symbol, tm.name, tm.contract_address;

[User] Now, restrict the results to only those tokens where total_amount exceeds 1,000,000.

[Assistant] SELECT tm.symbol, tm.name, tm.contract_address, SUM(CAST(ebh.amount AS DECIMAL)) AS total_amount, COUNT(DISTINCT ebh.wallet_address) AS unique_wallets FROM token_metas tm JOIN erc20_balances_historical ebh ON tm.contract_address = ebh.contract_address WHERE tm.is_erc20 = 1 AND tm.symbol LIKE '%X' GROUP BY tm.symbol, tm.name, tm.contract_address HAVING SUM(CAST(ebh.amount AS DECIMAL)) > 1000000;

[User] Please sort the results by the total_amount in descending order and limit to the top 5 tokens.

[Assistant] SELECT tm.symbol, tm.name, tm.contract_address, SUM(CAST(ebh.amount AS DECIMAL)) AS total_amount, COUNT(DISTINCT ebh.wallet_address) AS unique_wallets FROM token_metas tm JOIN erc20_balances_historical ebh ON tm.contract_address = ebh.contract_address WHERE tm.is_erc20 = 1 AND tm.symbol LIKE '%X' GROUP BY tm.symbol, tm.name, tm.contract_address HAVING SUM(CAST(ebh.amount AS DECIMAL)) > 1000000 ORDER BY total_amount DESC LIMIT 5;