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 hospitality_technology.properties ( property_id.text, property_name.text, address_line1.text, address_line2.text, city.text, state_province.text, postal_code.text, country_code.text, phone_number.text, email_address.text, property_type.text, star_rating.numeric, timezone.text, manager_staff_id.text, created_at.timestamp, updated_at.timestamp )
CREATE TABLE hospitality_technology.room_types ( room_type_id.text, property_id.text, type_name.text, description.text, base_rate.numeric, max_occupancy.integer, bed_type.text, area_sqft.numeric, amenities.text )
CREATE TABLE hospitality_technology.guests ( guest_id.text, first_name.text, last_name.text, email.text, phone_number.text, date_of_birth.date, address_line1.text, city.text, state_province.text, postal_code.text, country_code.text, preferences.text, loyalty_member_id.text, communication_consent.boolean, created_at.timestamp, updated_at.timestamp )
CREATE TABLE hospitality_technology.service_orders ( order_id.text, reservation_id.text, guest_id.text, service_id.text, staff_id_ordered.text, staff_id_delivered.text, order_timestamp.timestamp, delivery_timestamp.timestamp, quantity.integer, unit_price.numeric, total_price.numeric, status.text, notes.text, bill_id.text )

[User] Show me all spa service orders (service_id LIKE 'SPA%') in the last month with their guest names and total prices, ordered by total price in descending order.

[Assistant] SELECT so.order_id, g.first_name, g.last_name, so.total_price FROM hospitality_technology.service_orders so JOIN hospitality_technology.guests g ON so.guest_id = g.guest_id WHERE so.service_id LIKE 'SPA%' AND so.order_timestamp >= DATE_SUB(CURRENT_DATE, INTERVAL 1 MONTH) ORDER BY so.total_price DESC;

[User] Now, include only orders with a total price over $100 and show the property ID where the service was delivered.

[Assistant] SELECT so.order_id, g.first_name, g.last_name, so.total_price, r.property_id FROM hospitality_technology.service_orders so JOIN hospitality_technology.guests g ON so.guest_id = g.guest_id JOIN hospitality_technology.reservations r ON so.reservation_id = r.reservation_id WHERE so.service_id LIKE 'SPA%' AND so.order_timestamp >= DATE_SUB(CURRENT_DATE, INTERVAL 1 MONTH) AND so.total_price > 100 ORDER BY so.total_price DESC;

[User] The query is missing the service description. Can you include that as well?

[Assistant] SELECT so.order_id, g.first_name, g.last_name, so.total_price, r.property_id, s.description FROM hospitality_technology.service_orders so JOIN hospitality_technology.guests g ON so.guest_id = g.guest_id JOIN hospitality_technology.reservations r ON so.reservation_id = r.reservation_id JOIN hospitality_technology.services s ON so.service_id = s.service_id WHERE so.service_id LIKE 'SPA%' AND so.order_timestamp >= DATE_SUB(CURRENT_DATE, INTERVAL 1 MONTH) AND so.total_price > 100 ORDER BY so.total_price DESC;

[User] Actually, I need to see only orders delivered by staff with ID starting with 'STAFF1', and include the delivery timestamp.

[Assistant] SELECT so.order_id, g.first_name, g.last_name, so.total_price, r.property_id, s.description, so.delivery_timestamp FROM hospitality_technology.service_orders so JOIN hospitality_technology.guests g ON so.guest_id = g.guest_id JOIN hospitality_technology.reservations r ON so.reservation_id = r.reservation_id JOIN hospitality_technology.services s ON so.service_id = s.service_id WHERE so.service_id LIKE 'SPA%' AND so.order_timestamp >= DATE_SUB(CURRENT_DATE, INTERVAL 1 MONTH) AND so.total_price > 100 AND so.staff_id_delivered LIKE 'STAFF1%' ORDER BY so.total_price 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 transportation.drivers ( driver_id text PRIMARY KEY, employee_id text, first_name text, last_name text, license_number text, license_expiry_date date, contact_number text, email text, hire_date date, status text )

[User] List all drivers hired after January 1, 2021, with their driver_id, full name, and hire_date.

[Assistant] SELECT driver_id, first_name || ' ' || last_name AS full_name, hire_date FROM transportation.drivers WHERE hire_date > '2021-01-01';

[User] Also, only include those whose status is 'Active'.

[Assistant] SELECT driver_id, first_name || ' ' || last_name AS full_name, hire_date FROM transportation.drivers WHERE hire_date > '2021-01-01' AND status = 'Active';

[User] Order the results by hire_date ascending and limit to 5.

[Assistant] SELECT driver_id, first_name || ' ' || last_name AS full_name, hire_date FROM transportation.drivers WHERE hire_date > '2021-01-01' AND status = 'Active' ORDER BY hire_date ASC LIMIT 5;

[User] Actually, remove the limit and include drivers hired before January 1, 2022 as well.

[Assistant] SELECT driver_id, first_name || ' ' || last_name AS full_name, hire_date FROM transportation.drivers WHERE hire_date > '2021-01-01' AND hire_date < '2022-01-01' AND status = 'Active' ORDER BY hire_date 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 hospitality_technology.reviews ( review_id text, property_id text, reservation_id text, guest_id text, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source text, review_date timestamp, is_public boolean, staff_response text, response_staff_id text, response_date timestamp )

[User] Give me a breakdown of the number of reviews per day for the last 14 days, including the review_date and review count.

[Assistant]
SELECT DATE(review_date) AS review_day, COUNT(*) AS review_count
FROM hospitality_technology.reviews
WHERE review_date >= CURRENT_DATE - INTERVAL '14 days'
GROUP BY DATE(review_date)
ORDER BY review_day ASC;

[User] Add the number of public reviews for each day in a separate column named public_review_count.

[Assistant]
SELECT DATE(review_date) AS review_day,
       COUNT(*) AS review_count,
       SUM(CASE WHEN is_public THEN 1 ELSE 0 END) AS public_review_count
FROM hospitality_technology.reviews
WHERE review_date >= CURRENT_DATE - INTERVAL '14 days'
GROUP BY DATE(review_date)
ORDER BY review_day ASC;

[User] Now, also include the number of reviews per day with a rating_overall below 3 as a column called low_rating_count.

[Assistant]
SELECT DATE(review_date) AS review_day,
       COUNT(*) AS review_count,
       SUM(CASE WHEN is_public THEN 1 ELSE 0 END) AS public_review_count,
       SUM(CASE WHEN rating_overall < 3 THEN 1 ELSE 0 END) AS low_rating_count
FROM hospitality_technology.reviews
WHERE review_date >= CURRENT_DATE - INTERVAL '14 days'
GROUP BY DATE(review_date)
ORDER BY review_day 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, 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.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, 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 character varying(64) NOT NULL, account_id character varying(64) NOT NULL UNIQUE, loan_type character varying(50) NOT NULL, principal_amount numeric(19, 4) NOT NULL, current_principal_balance numeric(19, 4) NOT NULL, interest_rate numeric(6, 4) NOT NULL, term_months integer NOT NULL, origination_date date NOT NULL, maturity_date date NOT NULL, monthly_payment numeric(12, 4), collateral_description text, status character varying(32) NOT NULL, PRIMARY KEY (loan_id), FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id) )

[User] For each loan, show the loan ID, principal amount, interest rate, and the balance and currency of the associated account.

[Assistant] SELECT l.loan_id, l.principal_amount, l.interest_rate, a.balance, a.currency FROM financial_services.loans l JOIN financial_services.accounts a ON l.account_id = a.account_id

[User] Restrict the list to loans originated in the last 12 months.

[Assistant] SELECT l.loan_id, l.principal_amount, l.interest_rate, a.balance, a.currency FROM financial_services.loans l JOIN financial_services.accounts a ON l.account_id = a.account_id WHERE l.origination_date >= CURRENT_DATE - INTERVAL '1 year'

[User] Also, only include accounts where the balance is greater than 10000.

[Assistant] SELECT l.loan_id, l.principal_amount, l.interest_rate, a.balance, a.currency FROM financial_services.loans l JOIN financial_services.accounts a ON l.account_id = a.account_id WHERE l.origination_date >= CURRENT_DATE - INTERVAL '1 year' AND a.balance > 10000

[User] Finally, sort the results by the loan interest rate in descending order.

[Assistant] SELECT l.loan_id, l.principal_amount, l.interest_rate, a.balance, a.currency FROM financial_services.loans l JOIN financial_services.accounts a ON l.account_id = a.account_id WHERE l.origination_date >= CURRENT_DATE - INTERVAL '1 year' AND a.balance > 10000 ORDER BY l.interest_rate 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.diagnoses (
    diagnosis_id character varying(64) NOT NULL, -- unique identifier for the diagnosis entry
    record_id character varying(64) NOT NULL, -- FK linking to the specific medical record entry
    patient_id character varying(64) NOT NULL, -- FK to patients table
    doctor_id character varying(64) NOT NULL, -- FK to doctors table (diagnosing doctor)
    diagnosis_code character varying(20) NOT NULL, -- standard code (e.g., ICD-10)
    code_type character varying(10) NOT NULL DEFAULT 'ICD-10', -- type of code used
    description text, -- textual description of the diagnosis
    diagnosis_date date NOT NULL, -- date the diagnosis was made
    status character varying(32) NOT NULL, -- e.g., Active, Resolved, Ruled Out
    is_chronic boolean DEFAULT false, -- flag for chronic conditions
    PRIMARY KEY (diagnosis_id)
)

[User] Can you list all chronic diagnoses made in January 2024, showing diagnosis_id, diagnosis_code, and status, along with the doctor_id who made each diagnosis?

[Assistant] SELECT diagnosis_id, diagnosis_code, status, doctor_id FROM healthcare.diagnoses WHERE is_chronic = true AND diagnosis_date >= '2024-01-01' AND diagnosis_date < '2024-02-01';

[User] Add the patient_id and sort the results first by doctor_id ascending and then diagnosis_date ascending.

[Assistant] SELECT diagnosis_id, diagnosis_code, status, doctor_id, patient_id FROM healthcare.diagnoses WHERE is_chronic = true AND diagnosis_date >= '2024-01-01' AND diagnosis_date < '2024-02-01' ORDER BY doctor_id ASC, diagnosis_date 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.doctors ( doctor_id text, first_name text, last_name text, specialty text, license_number text, phone_number text, email text, hospital_affiliation_id text, created_at timestamp, updated_at timestamp )
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.diagnoses ( diagnosis_id text, 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 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)
)
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 text, 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] Find all prescriptions for patients who have at least one appointment scheduled in the future. Show the prescription ID, patient ID, medication name, and the earliest future appointment time for that patient.

[Assistant] SELECT pr.prescription_id, pr.patient_id, m.medication_name, ( SELECT MIN(ap.appointment_time) FROM healthcare.appointments AS ap WHERE ap.patient_id = p.patient_id AND ap.appointment_time > CURRENT_TIMESTAMP ) AS earliest_future_appointment_time FROM healthcare.prescriptions AS pr JOIN healthcare.patients AS p ON pr.patient_id = p.patient_id JOIN healthcare.medications AS m ON pr.medication_id = m.medication_id WHERE p.patient_id IN ( SELECT patient_id FROM healthcare.appointments WHERE appointment_time > CURRENT_TIMESTAMP );


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 government_services.agencies ( agency_id.text, agency_name.text, jurisdiction_level.text, primary_contact_email.text, main_phone_number.text, website_url.text, established_date.date, parent_agency_id.text )

[User] Show me all agencies established after 2020 and their jurisdiction level.

[Assistant]
SELECT agency_id, agency_name, jurisdiction_level, established_date
FROM government_services.agencies
WHERE established_date > '2020-12-31';

[User] Can you also include their parent agency's name in the result?

[Assistant]
SELECT a.agency_id, a.agency_name, a.jurisdiction_level, a.established_date, p.agency_name AS parent_agency_name
FROM government_services.agencies a
LEFT JOIN government_services.agencies p ON a.parent_agency_id = p.agency_id
WHERE a.established_date > '2020-12-31';

[User] Only show agencies where the parent agency's jurisdiction level is 'Federal'.

[Assistant]
SELECT a.agency_id, a.agency_name, a.jurisdiction_level, a.established_date, p.agency_name AS parent_agency_name
FROM government_services.agencies a
INNER JOIN government_services.agencies p ON a.parent_agency_id = p.agency_id
WHERE a.established_date > '2020-12-31' AND p.jurisdiction_level = 'Federal';

[User] Sort the list by established date descending and show only the top 5 agencies.

[Assistant]
SELECT a.agency_id, a.agency_name, a.jurisdiction_level, a.established_date, p.agency_name AS parent_agency_name
FROM government_services.agencies a
INNER JOIN government_services.agencies p ON a.parent_agency_id = p.agency_id
WHERE a.established_date > '2020-12-31' AND p.jurisdiction_level = 'Federal'
ORDER BY a.established_date DESC
LIMIT 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 gaming_technology.games (
    game_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game
    title character varying(200) NOT NULL, -- official title of the game
    developer_id uuid NOT NULL, -- FK linking to the developers table
    publisher_id uuid, -- FK linking to a potential publishers table (optional)
    genre character varying(100), -- primary genre (e.g., RPG, FPS, Strategy)
    release_date date, -- official release date
    description text, -- short description or synopsis of the game
    platform character varying(50) NOT NULL, -- primary platform (e.g., PC, PlayStation 5, Xbox Series X, Mobile)
    engine character varying(100), -- game engine used (e.g., Unreal Engine 5, Unity)
    website character varying(255), -- official website URL
    PRIMARY KEY (game_id)
    -- FOREIGN KEY (developer_id) REFERENCES gaming_technology.developers(developer_id) -- Example FK constraint
)
CREATE TABLE gaming_technology.game_sessions ( session_id uuid, player_id uuid, game_id uuid, server_id uuid, start_time timestamp with time zone, end_time timestamp with time zone, duration_seconds integer, score integer, session_data jsonb )
CREATE TABLE gaming_technology.servers ( server_id uuid, game_id uuid, server_name text, region text, ip_address text, port integer, current_players integer, max_players integer, status text, last_heartbeat timestamp with time zone )
CREATE TABLE gaming_technology.in_game_items (
    item_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the item definition
    game_id uuid NOT NULL, -- FK linking to the game this item belongs to
    item_name character varying(150) NOT NULL, -- name of the item
    item_type character varying(50) NOT NULL, -- type (e.g., Cosmetic, Consumable, Weapon, Armor)
    description text, -- description of the item
    rarity character varying(30), -- item rarity (e.g., Common, Rare, Epic, Legendary)
    cost_currency character varying(10), -- currency code if purchasable (e.g., USD, EUR, GOLD)
    cost_amount numeric(12, 2), -- price if purchasable
    attributes jsonb, -- flexible field for item stats or properties
    PRIMARY KEY (item_id)
    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)
)

[User] List all games and the servers hosting them, showing the game title, server name, region, and status.

[Assistant] SELECT g.title, s.server_name, s.region, s.status FROM gaming_technology.games g JOIN gaming_technology.servers s ON g.game_id = s.game_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 government_services.agencies ( agency_id.text, agency_name.text, jurisdiction_level.text, primary_contact_email.text, main_phone_number.text, website_url.text, established_date.date, parent_agency_id.text )
CREATE TABLE government_services.services ( service_id.text, agency_id.text, service_name.text, description.text, category.text, eligibility_criteria.text, standard_fee.numeric, average_processing_time_days.integer, is_active.boolean, online_application_url.text )
CREATE TABLE government_services.applications ( application_id.text, citizen_id.text, service_id.text, submitted_at.timestamp, status.text, last_updated_at.timestamp, assigned_employee_id.text, decision_date.date, notes.text, reference_number.text )
CREATE TABLE government_services.documents ( document_id.text, application_id.text, citizen_id.text, document_type.text, file_reference.text, upload_timestamp.timestamp, expiry_date.date, verification_status.text, verified_by_employee_id.text, verification_timestamp.timestamp )
CREATE TABLE government_services.payments ( payment_id.text, application_id.text, citizen_id.text, service_id.text, amount.numeric, currency.text, payment_method.text, payment_provider_reference.text, payment_timestamp.timestamp, status.text, notes.text )
CREATE TABLE government_services.service_locations ( location_id.text, agency_id.text, location_name.text, address.text, city.text, state.text, postal_code.text, latitude.numeric, longitude.numeric, operating_hours.text, contact_phone.text, is_accessible.boolean )
CREATE TABLE government_services.appointments ( appointment_id.text, citizen_id.text, employee_id.text, location_id.text, service_id.text, scheduled_start_time.timestamp, scheduled_end_time.timestamp, purpose.text, status.text, booking_method.text, created_at.timestamp, notes.text )
CREATE TABLE government_services.notifications ( notification_id.text, citizen_id.text, application_id.text, message_subject.text, message_body.text, channel.text, sent_at.timestamp, status.text, related_entity_type.text, related_entity_id.text )

[User] Show the total number of notifications sent per service category for applications submitted in 2024.

[Assistant] SELECT s.category, COUNT(n.notification_id) AS notification_count FROM government_services.notifications n JOIN government_services.applications ap ON ap.application_id = n.application_id JOIN government_services.services s ON s.service_id = ap.service_id WHERE ap.submitted_at >= '2024-01-01' AND ap.submitted_at < '2025-01-01' GROUP BY s.category;

[User] Exclude notifications with status 'Failed'.

[Assistant] SELECT s.category, COUNT(n.notification_id) AS notification_count FROM government_services.notifications n JOIN government_services.applications ap ON ap.application_id = n.application_id JOIN government_services.services s ON s.service_id = ap.service_id WHERE ap.submitted_at >= '2024-01-01' AND ap.submitted_at < '2025-01-01' AND n.status <> 'Failed' GROUP BY s.category;

[User] Also include only categories with more than 100 notifications.

[Assistant] SELECT s.category, COUNT(n.notification_id) AS notification_count FROM government_services.notifications n JOIN government_services.applications ap ON ap.application_id = n.application_id JOIN government_services.services s ON s.service_id = ap.service_id WHERE ap.submitted_at >= '2024-01-01' AND ap.submitted_at < '2025-01-01' AND n.status <> 'Failed' GROUP BY s.category HAVING COUNT(n.notification_id) > 100;

[User] Order the categories by notification_count descending and limit to the top 5.

[Assistant] SELECT s.category, COUNT(n.notification_id) AS notification_count FROM government_services.notifications n JOIN government_services.applications ap ON ap.application_id = n.application_id JOIN government_services.services s ON s.service_id = ap.service_id WHERE ap.submitted_at >= '2024-01-01' AND ap.submitted_at < '2025-01-01' AND n.status <> 'Failed' GROUP BY s.category HAVING COUNT(n.notification_id) > 100 ORDER BY notification_count DESC LIMIT 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.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.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.logs ( log_id text PRIMARY KEY, user_id text, action text, details text, logged_at timestamp )

[User] For each user, list their order_id, order_type, and any log messages they have generated.

[Assistant]
SELECT
  o.user_id,
  o.order_id,
  o.order_type,
  l.action AS log_message
FROM trading_platform.orders o
JOIN trading_platform.logs l
  ON o.user_id = l.user_id;

[User] Show only orders placed after '2024-06-01'.

[Assistant]
SELECT
  o.user_id,
  o.order_id,
  o.order_type,
  l.action AS log_message
FROM trading_platform.orders o
JOIN trading_platform.logs l
  ON o.user_id = l.user_id
WHERE o.created_at > '2024-06-01';

[User] Also filter logs to only those with action containing 'order'.

[Assistant]
SELECT
  o.user_id,
  o.order_id,
  o.order_type,
  l.action AS log_message
FROM trading_platform.orders o
JOIN trading_platform.logs l
  ON o.user_id = l.user_id
WHERE o.created_at > '2024-06-01'
  AND l.action ILIKE '%order%';

[User] Finally, sort by o.created_at descending and limit to 10.

[Assistant]
SELECT
  o.user_id,
  o.order_id,
  o.order_type,
  l.action AS log_message
FROM trading_platform.orders o
JOIN trading_platform.logs l
  ON o.user_id = l.user_id
WHERE o.created_at > '2024-06-01'
  AND l.action ILIKE '%order%'
ORDER BY o.created_at DESC
LIMIT 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 insurance.policies ( policy_id.text, customer_id.text, product_id.text, agent_id.text, policy_number.text, start_date.date, end_date.date, premium_amount.numeric, coverage_limit.numeric, deductible.numeric, status.text, issued_at.timestamp, cancellation_date.date, cancellation_reason.text )
CREATE TABLE insurance.claims ( claim_id.text, policy_id.text, customer_id.text, incident_date.timestamp, reported_date.timestamp, description.text, estimated_loss.numeric, status.text, settlement_amount.numeric, settlement_date.date, claim_handler_id.text, police_report_number.text )
CREATE TABLE insurance.premium_payments ( payment_id.text, policy_id.text, customer_id.text, payment_date.timestamp, amount_paid.numeric, payment_method.text, transaction_reference.text, due_date.date, payment_period_start.date, payment_period_end.date, status.text )

[User] Show me all active policies with coverage limits above $1,000,000, along with the customer names and agent names, sorted by coverage limit in descending order.

[Assistant] SELECT p.policy_id, p.customer_id, p.agent_id, p.coverage_limit, p.premium_amount, p.start_date, p.end_date FROM insurance.policies p WHERE p.status = 'active' AND p.coverage_limit > 1000000 ORDER BY p.coverage_limit DESC;

[User] Actually, I need to see the customer's first and last name from the customers table and the agent's full name from the agents table as well.

[Assistant] SELECT p.policy_id, p.coverage_limit, p.premium_amount, c.first_name AS customer_first_name, c.last_name AS customer_last_name, a.first_name AS agent_first_name, a.last_name AS agent_last_name FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id JOIN insurance.agents a ON p.agent_id = a.agent_id WHERE p.status = 'active' AND p.coverage_limit > 1000000 ORDER BY p.coverage_limit DESC;

[User] Now I also want to see the total number of claims each of these high-coverage policies has had.

[Assistant] SELECT p.policy_id, p.coverage_limit, p.premium_amount, c.first_name AS customer_first_name, c.last_name AS customer_last_name, a.first_name AS agent_first_name, a.last_name AS agent_last_name, COUNT(cl.claim_id) AS total_claims FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id JOIN insurance.agents a ON p.agent_id = a.agent_id LEFT JOIN insurance.claims cl ON p.policy_id = cl.policy_id WHERE p.status = 'active' AND p.coverage_limit > 1000000 GROUP BY p.policy_id, p.coverage_limit, p.premium_amount, c.first_name, c.last_name, a.first_name, a.last_name ORDER BY p.coverage_limit DESC;

[User] Finally, filter these results to only show policies that have at least one claim and include the average settlement amount for those claims.

[Assistant] SELECT p.policy_id, p.coverage_limit, p.premium_amount, c.first_name AS customer_first_name, c.last_name AS customer_last_name, a.first_name AS agent_first_name, a.last_name AS agent_last_name, COUNT(cl.claim_id) AS total_claims, AVG(cl.settlement_amount) AS avg_settlement FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id JOIN insurance.agents a ON p.agent_id = a.agent_id JOIN insurance.claims cl ON p.policy_id = cl.policy_id WHERE p.status = 'active' AND p.coverage_limit > 1000000 GROUP BY p.policy_id, p.coverage_limit, p.premium_amount, c.first_name, c.last_name, a.first_name, a.last_name HAVING COUNT(cl.claim_id) > 0 ORDER BY p.coverage_limit DESC;


[User] Show me the top 5 guests who have submitted the most reviews. Include guest_id and review_count.

[Assistant]
SELECT guest_id, COUNT(*) AS review_count
FROM hospitality_technology.reviews
GROUP BY guest_id
ORDER BY review_count DESC
LIMIT 5;

[User] Also include their highest overall rating given in any review.

[Assistant]
SELECT guest_id, COUNT(*) AS review_count, MAX(rating_overall) AS max_rating_overall
FROM hospitality_technology.reviews
GROUP BY guest_id
ORDER BY review_count DESC
LIMIT 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 transportation.vehicles ( vehicle_id.text, license_plate.text, vin.text, make.text, model.text, year.integer, type.text, capacity.integer, fuel_type.text, status.text, depot_id.text, acquisition_date.date )
CREATE TABLE transportation.trips ( trip_id.text, route_id.text, vehicle_id.text, driver_id.text, scheduled_departure.timestamp, actual_departure.timestamp, scheduled_arrival.timestamp, actual_arrival.timestamp, origin_location_id.text, destination_location_id.text, status.text, passenger_count.integer, cargo_manifest_id.text )
CREATE TABLE transportation.locations ( location_id.text, name.text, type.text, address_line1.text, city.text, state_province.text, postal_code.text, country.text, latitude.numeric, longitude.numeric, timezone.text )
CREATE TABLE transportation.maintenance_logs ( log_id.text, vehicle_id.text, service_date.date, odometer_reading.integer, service_type.text, description.text, cost.numeric, mechanic_name.text, next_service_due_date.date )
CREATE TABLE transportation.fuel_logs ( fuel_log_id.text, vehicle_id.text, trip_id.text, log_timestamp.timestamp, fuel_type.text, quantity.numeric, unit.text, cost_per_unit.numeric, total_cost.numeric, odometer_reading.integer, location_id.text )
CREATE TABLE transportation.passengers ( passenger_id.text, first_name.text, last_name.text, email.text, phone_number.text, date_of_birth.date, loyalty_program_id.text, created_at.timestamp )

[User] Calculate the total fuel quantity and total cost consumed for each trip where passenger_count > 50. List trip_id, total_quantity, and total_cost.

[Assistant]
SELECT f.trip_id,
       SUM(f.quantity) AS total_quantity,
       SUM(f.total_cost) AS total_cost
FROM transportation.fuel_logs f
JOIN transportation.trips t
  ON f.trip_id = t.trip_id
WHERE t.passenger_count > 50
GROUP BY f.trip_id;

[User] Also include the vehicle make and model for each trip, and order by total_cost descending.

[Assistant]
SELECT f.trip_id,
       SUM(f.quantity) AS total_quantity,
       SUM(f.total_cost) AS total_cost,
       v.make,
       v.model
FROM transportation.fuel_logs f
JOIN transportation.trips t
  ON f.trip_id = t.trip_id
JOIN transportation.vehicles v
  ON t.vehicle_id = v.vehicle_id
WHERE t.passenger_count > 50
GROUP BY f.trip_id, v.make, v.model
ORDER BY total_cost 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.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.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.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )

[User] Find all medications where the generic name includes the text 'hydrochloride'. Display the medication name and generic name.

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


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 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 character varying(64) NOT NULL,  -- unique identifier for the law firm
    firm_name character varying(200) NOT NULL, -- official name of the law firm
    address text NOT NULL, -- primary address of the firm
    phone character varying(32), -- firm's main phone number
    website character varying(255), -- firm's website URL
    founded_date date, -- date the firm was established
    managing_partner_id character varying(64), -- FK to lawyers table (optional)
    PRIMARY KEY (firm_id)
)
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.documents (
    document_id character varying(64) NOT NULL,  -- unique identifier for the document
    case_id character varying(64) NOT NULL, -- FK to cases table
    document_name character varying(255) NOT NULL, -- name of the document file
    document_type character varying(100), -- e.g., Pleading, Contract, Evidence, Correspondence
    storage_path text NOT NULL, -- path or reference to the document storage location
    uploaded_by_lawyer_id character varying(64), -- FK to lawyers table (who uploaded it)
    upload_timestamp timestamp NOT NULL, -- time the document was uploaded
    version integer DEFAULT 1, -- document version number
    description text, -- brief description or notes about the document
    PRIMARY KEY (document_id)
)
CREATE TABLE legal_services.time_entries (
    entry_id character varying(64) NOT NULL,  -- unique identifier for the time entry
    case_id character varying(64) NOT NULL, -- FK to cases table
    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table (who performed the work)
    date_worked date NOT NULL, -- date the work was performed
    hours_spent numeric(5, 2) NOT NULL CHECK (hours_spent > 0), -- duration of work in hours (e.g., 1.5 for 1h 30m)
    billing_rate numeric(10, 2) NOT NULL, -- hourly rate applied for this entry
    description text NOT NULL, -- detailed description of the work performed
    is_billable boolean DEFAULT true, -- whether this time entry is billable to the client
    is_billed boolean DEFAULT false, -- whether this entry has been included in an invoice
    invoice_id character varying(64), -- FK to invoices table (once billed)
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the entry was recorded
    PRIMARY KEY (entry_id)
)
CREATE TABLE legal_services.invoices (
    invoice_id character varying(64) NOT NULL,  -- unique identifier for the invoice
    invoice_number character varying(100) UNIQUE NOT NULL, -- user-facing invoice number
    client_id character varying(64) NOT NULL, -- FK to clients table
    case_id character varying(64), -- FK to cases table (optional, could be general retainer)
    issue_date date NOT NULL, -- date the invoice was generated
    due_date date NOT NULL, -- date the payment is due
    total_amount numeric(12, 2) NOT NULL, -- total amount due on the invoice
    amount_paid numeric(12, 2) DEFAULT 0.00, -- amount already paid
    status character varying(50) NOT NULL, -- e.g., Draft, Sent, Paid, Partially Paid, Overdue, Void
    payment_date timestamp, -- date the invoice was fully paid (nullable)
    notes text, -- additional notes or terms on the invoice
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (invoice_id)
)
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] Get the total number and total amount of invoices issued in 2023.

[Assistant]
SELECT COUNT(*) AS invoice_count,
       SUM(total_amount) AS total_amount
FROM legal_services.invoices
WHERE issue_date BETWEEN '2023-01-01' AND '2023-12-31';

[User] But exclude those that are in Draft status.

[Assistant]
SELECT COUNT(*) AS invoice_count,
       SUM(total_amount) AS total_amount
FROM legal_services.invoices
WHERE issue_date BETWEEN '2023-01-01' AND '2023-12-31'
  AND status <> 'Draft';

[User] Now group the result by status for these invoices.

[Assistant]
SELECT status,
       COUNT(*) AS invoice_count,
       SUM(total_amount) AS total_amount
FROM legal_services.invoices
WHERE issue_date BETWEEN '2023-01-01' AND '2023-12-31'
  AND status <> 'Draft'
GROUP BY status;

[User] Finally, sort by total_amount descending.

[Assistant]
SELECT status,
       COUNT(*) AS invoice_count,
       SUM(total_amount) AS total_amount
FROM legal_services.invoices
WHERE issue_date BETWEEN '2023-01-01' AND '2023-12-31'
  AND status <> 'Draft'
GROUP BY status
ORDER BY 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 social_media.messages (
    message_id character varying(64) NOT NULL, -- unique identifier for the message
    conversation_id character varying(64) NOT NULL, -- identifier for the conversation thread (FK to conversations.conversation_id)
    sender_user_id character varying(64) NOT NULL, -- identifier of the sender (FK to users.user_id)
    content text, -- textual content of the message
    media_url text, -- URL to attached media (image/video)
    media_type character varying(20), -- type of media ('image', 'video', null)
    sent_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when message was sent
    read_at timestamp, -- timestamp when message was read by recipient(s)
    PRIMARY KEY (message_id)
)

[User] List the last 20 messages that have a media_url, showing message_id, sender_user_id, media_type, and sent_at, ordered by sent_at descending.

[Assistant]
SELECT message_id,
       sender_user_id,
       media_type,
       sent_at
FROM social_media.messages
WHERE media_url IS NOT NULL
ORDER BY sent_at DESC
LIMIT 20;


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(6) NOT NULL, block_number bigint NOT NULL, transaction_hash varchar NOT NULL, transaction_index bigint NOT NULL, from_address varchar NOT NULL, contract_address varchar NOT NULL, symbol varchar NOT NULL, total_supply varchar NOT NULL, name varchar NOT NULL, decimals bigint NOT NULL, is_erc20 integer NOT NULL, is_erc721 integer NOT NULL, is_erc1155 integer NOT NULL, is_proxy integer NOT NULL, extra_info varchar NOT NULL, pk integer NOT NULL )
CREATE TABLE erc20_balances ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )
CREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )
CREATE TABLE nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )
CREATE TABLE nft_holder_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )
CREATE TABLE nft_metadata ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, token_id varchar NOT NULL, contract_name varchar NOT NULL, erc_type varchar NOT NULL, amount bigint NOT NULL, minter varchar NOT NULL, owner varchar NOT NULL, mint_block_number bigint NOT NULL, mint_time bigint NOT NULL, mint_transaction_hash varchar NOT NULL, mint_price varchar NOT NULL, token_uri varchar NOT NULL, metadata varchar NOT NULL, name varchar NOT NULL, image_uri varchar NOT NULL, traits varchar NOT NULL, updated_at bigint NOT NULL, status varchar NOT NULL, rarity_score real NOT NULL, rarity_rank integer NOT NULL, unique_attribute_count integer NOT NULL, pk integer NOT NULL )
CREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )
CREATE TABLE token_prices ( uuid varchar(36) NOT NULL, blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )
CREATE TABLE token_prices_latest ( blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )
CREATE TABLE erc20_approval ( block_number bigint NOT NULL, block_timestamp timestamp(6) NOT NULL, transaction_index integer NOT NULL, transaction_hash varchar NOT NULL, log_index integer NOT NULL, contract_address varchar NOT NULL, pk integer NOT NULL )
CREATE TABLE token_activities ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar NOT NULL, tick varchar NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(42) NOT NULL, to_address varchar(42) NOT NULL )
CREATE TABLE mud_holesky_redstone ( address varchar NOT NULL, table_id varchar NOT NULL, key_bytes varchar NOT NULL, key0 varchar NOT NULL, key1 varchar NOT NULL, static_data varchar NOT NULL, encoded_lengths varchar NOT NULL, dynamic_data varchar NOT NULL, is_deleted boolean NOT NULL, block_number bigint NOT NULL, log_index bigint NOT NULL )
CREATE TABLE token_balances_bitcoin ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar(255) NOT NULL, wallet_address varchar(42) NOT NULL, total_supply varchar NOT NULL, amount varchar NOT NULL )
CREATE TABLE token_activities_bitcoin ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(62) NOT NULL, to_address varchar(62) NOT NULL )
CREATE TABLE token_info_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar(20) NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL, minted decimal(38,0) NOT NULL, holders decimal(38,0) NOT NULL, txs decimal(38,0) NOT NULL, updated_timestamp timestamp(3) NOT NULL, completed_timestamp timestamp(3) NOT NULL, id varchar(255) NOT NULL )

[User] For all NFT collections on the Ethereum blockchain, show me the collection name and the current floor price. Sort by floor price descending.

[Assistant] SELECT name, floor_price FROM nft_collections WHERE blockchain = 'Ethereum' ORDER BY CAST(floor_price AS FLOAT) DESC;

[User] Include also the collection symbol and the number of tokens in each collection.

[Assistant] SELECT name, symbol, floor_price, token_count FROM nft_collections WHERE blockchain = 'Ethereum' ORDER BY CAST(floor_price AS FLOAT) DESC;

[User] Can you also show the owner of each collection in the result?

[Assistant] SELECT name, symbol, floor_price, token_count, owner FROM nft_collections WHERE blockchain = 'Ethereum' ORDER BY CAST(floor_price AS FLOAT) DESC;

[User] Now only include collections whose floor price is greater than 1 ETH.

[Assistant] SELECT name, symbol, floor_price, token_count, owner FROM nft_collections WHERE blockchain = 'Ethereum' AND CAST(floor_price AS FLOAT) > 1 AND floor_price_symbol = 'ETH' ORDER BY CAST(floor_price AS FLOAT) 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 insurance.agents ( agent_id text PRIMARY KEY, first_name text, last_name text, agency_name text, license_number text, license_state text, contact_email text, contact_phone text, hire_date date, termination_date date, status text, commission_rate numeric, manager_id text )

[User] List all agents and their managers' full names.

[Assistant] SELECT a.first_name, a.last_name, m.first_name AS manager_first_name, m.last_name AS manager_last_name FROM insurance.agents a LEFT JOIN insurance.agents m ON a.manager_id = m.agent_id;

[User] Filter the results to only include agents with a commission rate greater than 0.05.

[Assistant] SELECT a.first_name, a.last_name, m.first_name AS manager_first_name, m.last_name AS manager_last_name FROM insurance.agents a LEFT JOIN insurance.agents m ON a.manager_id = m.agent_id WHERE a.commission_rate > 0.05;

[User] From those results, also only show agents whose manager is licensed in 'CA'.

[Assistant] SELECT a.first_name, a.last_name, m.first_name AS manager_first_name, m.last_name AS manager_last_name FROM insurance.agents a JOIN insurance.agents m ON a.manager_id = m.agent_id WHERE a.commission_rate > 0.05 AND m.license_state = 'CA';

[User] Please refine the output to only include the agent's first name, last name, and the manager's full name, sorted by manager's last name descending, and limit to the top 5.

[Assistant] SELECT a.first_name, a.last_name, m.first_name AS manager_first_name, m.last_name AS manager_last_name FROM insurance.agents a JOIN insurance.agents m ON a.manager_id = m.agent_id WHERE a.commission_rate > 0.05 AND m.license_state = 'CA' ORDER BY m.last_name DESC LIMIT 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 hospitality_technology.rooms (
    room_id character varying(64) NOT NULL,  -- unique identifier for the room
    property_id character varying(64) NOT NULL, -- FK to properties table
    room_number character varying(10) NOT NULL, -- room number identifier (e.g., '101', 'Suite 2B')
    room_type_id character varying(64) NOT NULL, -- FK to room_types table
    floor integer, -- floor number the room is on
    status character varying(50) NOT NULL, -- e.g., Available, Occupied, Cleaning, OutOfOrder, Maintenance
    is_smoking boolean NOT NULL DEFAULT false, -- smoking allowed flag
    features text, -- description of features (e.g., Balcony, Sea View, Jacuzzi)
    current_condition text, -- notes on room condition
    last_cleaned_at timestamp with time zone, -- timestamp of last cleaning
    PRIMARY KEY (room_id),
    FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id),
    FOREIGN KEY (room_type_id) REFERENCES hospitality_technology.room_types(room_type_id)
)

[User] List all rooms that have not been cleaned in the last 7 days, showing their room number, property ID, and last cleaned date.

[Assistant] SELECT room_number, property_id, last_cleaned_at FROM hospitality_technology.rooms WHERE last_cleaned_at < NOW() - INTERVAL '7 days';

[User] Now, only include those rooms with status 'Occupied' or 'Cleaning', and sort the results by last cleaned date descending.

[Assistant] SELECT room_number, property_id, last_cleaned_at FROM hospitality_technology.rooms WHERE last_cleaned_at < NOW() - INTERVAL '7 days' AND status IN ('Occupied', 'Cleaning') ORDER BY last_cleaned_at 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 gaming_technology.players ( player_id uuid PRIMARY KEY, username text, email text, password_hash text, registration_date timestamptz, last_login timestamptz, country_code text, status text, profile_data jsonb )
CREATE TABLE gaming_technology.game_sessions ( session_id uuid PRIMARY KEY, player_id uuid, game_id uuid, server_id uuid, start_time timestamptz, end_time timestamptz, duration_seconds int, score int, session_data jsonb )
CREATE TABLE gaming_technology.servers ( server_id uuid PRIMARY KEY, game_id uuid, server_name text, region text, ip_address text, port int, current_players int, max_players int, status text, last_heartbeat timestamptz )
CREATE TABLE gaming_technology.in_game_items ( item_id uuid PRIMARY KEY, game_id uuid, item_name text, item_type text, description text, rarity text, cost_currency text, cost_amount numeric, attributes jsonb )

[User] Show me the usernames of players who have participated in game sessions on servers located in the same region as server 'XYZ', along with the server name and the region.

[Assistant]
SELECT DISTINCT p.username, s.server_name, s.region
FROM gaming_technology.game_sessions gs
JOIN gaming_technology.players p ON gs.player_id = p.player_id
JOIN gaming_technology.servers s ON gs.server_id = s.server_id
WHERE s.region = (SELECT region FROM gaming_technology.servers WHERE server_id = 'XYZ');

[User] Also, include the start time of each session in the output.

[Assistant]
SELECT p.username, s.server_name, s.region, gs.start_time
FROM gaming_technology.game_sessions gs
JOIN gaming_technology.players p ON gs.player_id = p.player_id
JOIN gaming_technology.servers s ON gs.server_id = s.server_id
WHERE s.region = (SELECT region FROM gaming_technology.servers WHERE server_id = 'XYZ');


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 transportation.routes ( route_id text, route_number text, description text, origin_location_id text, destination_location_id text, distance_km numeric, estimated_duration_minutes integer, type text )
CREATE TABLE transportation.trips (
    trip_id character varying(64) NOT NULL,  -- unique identifier for a specific trip instance
    route_id character varying(64), -- identifier of the route being followed (can be null for ad-hoc trips)
    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle used
    driver_id character varying(64) NOT NULL, -- identifier of the driver operating
    scheduled_departure timestamp with time zone NOT NULL, -- planned departure time
    actual_departure timestamp with time zone, -- actual departure time
    scheduled_arrival timestamp with time zone NOT NULL, -- planned arrival time
    actual_arrival timestamp with time zone, -- actual arrival time
    origin_location_id character varying(64) NOT NULL, -- actual starting location (could differ from route origin)
    destination_location_id character varying(64) NOT NULL, -- actual ending location (could differ from route destination)
    status character varying(32) NOT NULL, -- e.g., Scheduled, In Progress, Completed, Delayed, Cancelled
    passenger_count integer, -- number of passengers (if applicable)
    cargo_manifest_id character varying(64), -- link to cargo details (if applicable)
    PRIMARY KEY (trip_id)
)
CREATE TABLE transportation.fuel_logs ( fuel_log_id text PRIMARY KEY, vehicle_id text, trip_id text, log_timestamp timestamp, fuel_type text, quantity numeric, unit text, cost_per_unit numeric, total_cost numeric, odometer_reading int, location_id text )
CREATE TABLE transportation.bookings (
    booking_id character varying(64) NOT NULL,  -- unique identifier for the booking
    passenger_id character varying(64) NOT NULL, -- identifier of the passenger making the booking
    trip_id character varying(64) NOT NULL, -- identifier of the trip being booked
    seat_number character varying(16), -- assigned seat number (if applicable)
    booking_time timestamp with time zone NOT NULL, -- time when the booking was made
    status character varying(32) NOT NULL, -- e.g., Confirmed, Cancelled, Pending Payment
    fare numeric(10, 2) NOT NULL, -- price paid for the booking
    payment_transaction_id character varying(128), -- reference to the payment transaction
    special_requests text, -- any special requests from the passenger
    PRIMARY KEY (booking_id)
)

[User] List all completed trips, showing the trip ID, the names of the origin and destination locations for the trip, and the actual arrival time.

[Assistant] SELECT t.trip_id, loc_origin.name AS origin_location_name, loc_dest.name AS destination_location_name, t.actual_arrival FROM transportation.trips t JOIN locations loc_origin ON t.origin_location_id = loc_origin.location_id JOIN locations loc_dest ON t.destination_location_id = loc_dest.location_id WHERE t.status = 'Completed';


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 project_fundraising_record ( id character varying(32) NOT NULL,  -- fundraising record id project_id character varying(32) NOT NULL, -- the invested project's id project_name character varying(128) NOT NULL, -- name of the invested project rounds_name character varying(32), -- name of the fundraising round investment_value numeric(38,14), -- amount of the fundraising in USD investment_date character varying(128), -- the date of the investment happened introduction character varying(128), -- the introduction of the invested project valuation numeric(38,14), -- the valuation of the project in USD when invested )
CREATE TABLE token_basic_info ( coin_id character varying(100) NOT NULL, token_name character varying(100) NOT NULL, token_symbol character varying(100) NOT NULL, token_address character varying(100) NOT NULL, chain text, price double precision, price_change_percentage_1h double precision, price_change_percentage_24h double precision, price_change_percentage_7d double precision, highest_price_24h double precision, lowest_price_24h double precision, market_cap double precision, market_cap_rank bigint, market_cap_change_percentage_24h text, total_volume text, narrative text, trend_rank bigint )
 "CREATE TABLE narrative_info (",
    "narrative character varying(512) NOT NULL, -- the id of narrative",
    "top_3_coins text, -- the top 3 tokens in the narrative",
    "price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour in the narrative",
    "price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours in the narrative",
    "price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days in the narrative",
    "market_cap double precision, -- the market cap of the narrative",
    "volume_24h double precision, -- the trade volume of the narrative",
    "trend_rank bigint, -- the trending rank of the narrative, value 1 expresses the most popular narrative",
    "token_num bigint, -- total token number in the narrative",
    ",PRIMARY KEY (narrative));"

CREATE TABLE cex_token_balance ( snapshot_time character varying(32) NOT NULL, chain character varying(128) NOT NULL, address character varying(128) NOT NULL, exchange character varying(512) NOT NULL, token_address character varying(128) NOT NULL, token_symbol character varying(512), balance numeric(38,10), usd_value numeric(38,14), price double precision )
CREATE TABLE smart_money_profit ( address character varying(100) NOT NULL, rank INT, profit numeric(38,6), roi numeric(38,2), realized_ratio numeric(38,2), most_profit_token character varying(100), last_trade_time character varying(100), chain character varying(100) )
CREATE TABLE smart_money_token_performance ( token_address character varying(100) NOT NULL, token_symbol character varying(100), pnl numeric(38,2), net_flow numeric(38,2), avg_cost numeric(38,16), price double precision, realized_ratio numeric(10,2), roi numeric(10,2), chain character varying(100) )

[User] Show me the top 5 projects by valuation that completed fundraising rounds in the last 3 months, along with their narrative information if available.

[Assistant] SELECT pfr.project_name, pfr.valuation, pfr.rounds_name, pfr.investment_date, ni.narrative, ni.trend_rank FROM project_fundraising_record pfr LEFT JOIN token_basic_info tbi ON pfr.project_name = tbi.token_name LEFT JOIN narrative_info ni ON tbi.narrative = ni.narrative WHERE pfr.investment_date >= DATE_SUB(CURRENT_DATE, INTERVAL 3 MONTH) ORDER BY pfr.valuation DESC LIMIT 5;

[User] Can you also include the 24-hour trading volume for these projects' narratives and filter to only include projects with valuation over $50 million?

[Assistant] SELECT pfr.project_name, pfr.valuation, pfr.rounds_name, pfr.investment_date, ni.narrative, ni.trend_rank, ni.volume_24h FROM project_fundraising_record pfr LEFT JOIN token_basic_info tbi ON pfr.project_name = tbi.token_name LEFT JOIN narrative_info ni ON tbi.narrative = ni.narrative WHERE pfr.investment_date >= DATE_SUB(CURRENT_DATE, INTERVAL 3 MONTH) AND pfr.valuation > 50000000 ORDER BY pfr.valuation DESC LIMIT 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 hospitality_technology.reservations ( reservation_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, guest_id character varying(64) NOT NULL, room_id character varying(64), room_type_id character varying(64) NOT NULL, check_in_date date NOT NULL, check_out_date date NOT NULL, actual_check_in_ts timestamp with time zone, actual_check_out_ts timestamp with time zone, num_adults integer NOT NULL, num_children integer DEFAULT 0, status character varying(50) NOT NULL, booking_source character varying(100), rate_plan_id character varying(64), total_amount numeric(12, 2), amount_paid numeric(12, 2) DEFAULT 0.00, special_requests text, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (reservation_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (room_id) REFERENCES hospitality_technology.rooms(room_id), FOREIGN KEY (room_type_id) REFERENCES hospitality_technology.room_types(room_type_id) )
CREATE TABLE hospitality_technology.reviews ( review_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, reservation_id character varying(64) UNIQUE, guest_id character varying(64) NOT NULL, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source character varying(100), review_date timestamp with time zone NOT NULL DEFAULT current_timestamp, is_public boolean DEFAULT true, staff_response text, response_staff_id character varying(64), response_date timestamp with time zone, PRIMARY KEY (review_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (response_staff_id) REFERENCES hospitality_technology.staff(staff_id) )

[User] List all reservations where the number of adults is greater than 2, showing reservation_id, guest_id, and the total_amount.

[Assistant]
SELECT reservation_id, guest_id, total_amount
FROM hospitality_technology.reservations
WHERE num_adults > 2;

[User] Can you also include the room_type_id and the status for each reservation?

[Assistant]
SELECT reservation_id, guest_id, room_type_id, status, total_amount
FROM hospitality_technology.reservations
WHERE num_adults > 2;


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 smart_money_profit ( address character varying(100) NOT NULL, rank INT, profit numeric(38,6), roi numeric(38,2), realized_ratio numeric(38,2), most_profit_token character varying(100), last_trade_time character varying(100), chain character varying(100) )

[User] What is the average ROI for all smart money addresses on the Binance chain?

[Assistant] SELECT AVG(roi) FROM smart_money_profit WHERE chain = 'Binance';


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 character varying(64) NOT NULL,  -- unique identifier for the user
    username character varying(128) NOT NULL, -- username of the user
    email character varying(128) NOT NULL, -- email address of the user
    password_hash text NOT NULL, -- hashed password of the user
    created_at timestamp NOT NULL, -- time when the user account was created
    PRIMARY KEY (user_id)
)
CREATE TABLE trading_platform.trades (
    trade_id character varying(64) NOT NULL,  -- unique identifier for the trade
    order_id character varying(64) NOT NULL, -- identifier of the order that led to the trade
    buyer_id character varying(64) NOT NULL, -- identifier of the buyer
    seller_id character varying(64) NOT NULL, -- identifier of the seller
    asset_id character varying(64) NOT NULL, -- identifier of the asset being traded
    quantity numeric(38,14) NOT NULL, -- quantity of the asset in the trade
    price numeric(38,14) NOT NULL, -- price per unit of the asset
    traded_at timestamp NOT NULL, -- time when the trade was executed
    PRIMARY KEY (trade_id)
)
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 character varying(64) NOT NULL,  -- unique identifier for the DApp
    name character varying(128) NOT NULL, -- name of the DApp
    description text NOT NULL, -- description of the DApp
    url character varying(256) NOT NULL, -- URL of the DApp
    PRIMARY KEY (dapp_id)
)

[User] Show the name, symbol, and total quantity traded for each asset.

[Assistant]
SELECT a.name, a.symbol, COALESCE(SUM(t.quantity), 0) AS total_quantity_traded
FROM trading_platform.assets a
LEFT JOIN trading_platform.trades t ON t.asset_id = a.asset_id
GROUP BY a.asset_id, a.name, a.symbol;

[User] Only show assets with a total traded quantity less than 50 and order them by total_quantity_traded ascending.

[Assistant]
SELECT a.name, a.symbol, COALESCE(SUM(t.quantity), 0) AS total_quantity_traded
FROM trading_platform.assets a
LEFT JOIN trading_platform.trades t ON t.asset_id = a.asset_id
GROUP BY a.asset_id, a.name, a.symbol
HAVING COALESCE(SUM(t.quantity), 0) < 50
ORDER BY total_quantity_traded ASC;

[User] Some assets have never been traded and do not appear in the result. Please include those assets as well, with total_quantity_traded as 0.

[Assistant]
SELECT a.name, a.symbol, COALESCE(SUM(t.quantity), 0) AS total_quantity_traded
FROM trading_platform.assets a
LEFT JOIN trading_platform.trades t ON t.asset_id = a.asset_id
GROUP BY a.asset_id, a.name, a.symbol
HAVING COALESCE(SUM(t.quantity), 0) < 50 OR SUM(t.quantity) IS NULL
ORDER BY total_quantity_traded ASC;

[User] I noticed that assets with no trades still appear, but the column name is inconsistent when there are no trades. Can you make sure total_quantity_traded always appears as 0 for such assets and is labeled consistently?

[Assistant]
SELECT a.name, a.symbol, COALESCE(SUM(t.quantity), 0) AS total_quantity_traded
FROM trading_platform.assets a
LEFT JOIN trading_platform.trades t ON t.asset_id = a.asset_id
GROUP BY a.asset_id, a.name, a.symbol
HAVING COALESCE(SUM(t.quantity), 0) < 50
ORDER BY total_quantity_traded 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.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.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 )
CREATE TABLE financial_services.transactions (
    transaction_id character varying(64) NOT NULL, -- unique identifier for the transaction
    account_id character varying(64) NOT NULL, -- account involved in the transaction
    related_account_id character varying(64), -- counterpart account for transfers
    transaction_type character varying(50) NOT NULL, -- e.g., Deposit, Withdrawal, Transfer, Payment, Fee, Interest
    amount numeric(19, 4) NOT NULL, -- transaction amount
    currency character varying(3) NOT NULL, -- transaction currency
    transaction_date timestamp NOT NULL, -- exact time of the transaction
    effective_date date NOT NULL, -- date the transaction affects the balance
    description text, -- description or memo of the transaction
    status character varying(32) NOT NULL, -- e.g., Pending, Completed, Failed, Reversed
    reference_number character varying(128), -- external reference if applicable (e.g., check number)
    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.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.loans ( loan_id character varying(64) NOT NULL, account_id character varying(64) NOT NULL UNIQUE, loan_type character varying(50) NOT NULL, principal_amount numeric(19, 4) NOT NULL, current_principal_balance numeric(19, 4) NOT NULL, interest_rate numeric(6, 4) NOT NULL, term_months integer NOT NULL, origination_date date NOT NULL, maturity_date date NOT NULL, monthly_payment numeric(12, 4), collateral_description text, status character varying(32) NOT NULL, PRIMARY KEY (loan_id), FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id) )

[User] Provide a daily summary of completed transfers showing the date, total amount, and count of transfers.

[Assistant]
SELECT effective_date,
       SUM(amount) AS total_transfer_amount,
       COUNT(*) AS transfer_count
FROM financial_services.transactions
WHERE transaction_type = 'Transfer'
  AND status = 'Completed'
GROUP BY effective_date;

[User] Only include days where the total transfer amount is greater than 5000.

[Assistant]
SELECT effective_date,
       SUM(amount) AS total_transfer_amount,
       COUNT(*) AS transfer_count
FROM financial_services.transactions
WHERE transaction_type = 'Transfer'
  AND status = 'Completed'
GROUP BY effective_date
HAVING SUM(amount) > 5000;

[User] And sort the results by date in descending order.

[Assistant]
SELECT effective_date,
       SUM(amount) AS total_transfer_amount,
       COUNT(*) AS transfer_count
FROM financial_services.transactions
WHERE transaction_type = 'Transfer'
  AND status = 'Completed'
GROUP BY effective_date
HAVING SUM(amount) > 5000
ORDER BY effective_date 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 insurance.claim_documents ( document_id.text, claim_id.text, document_type.text, file_name.text, file_path.text, file_size_bytes.integer, mime_type.text, uploaded_by.text, uploaded_at.timestamp, description.text )

[User] List all claim documents that do not have a description. Show the document_id, claim_id, file_name, and uploaded_at.

[Assistant] SELECT document_id, claim_id, file_name, uploaded_at FROM insurance.claim_documents WHERE description IS NULL OR description = '';


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 government_services.service_locations (
    location_id character varying(64) NOT NULL, -- unique identifier for the physical location
    agency_id character varying(64) NOT NULL, -- FK to agencies table
    location_name character varying(200), -- e.g., Downtown DMV Office
    address text NOT NULL,
    city character varying(100),
    state character varying(50),
    postal_code character varying(20),
    latitude numeric(9, 6),
    longitude numeric(9, 6),
    operating_hours text, -- description of opening times
    contact_phone character varying(32),
    is_accessible boolean, -- accessibility information (e.g., wheelchair access)
    PRIMARY KEY (location_id)
)

[User] List all states where we have more than two service locations, and display the number of locations per state.

[Assistant] SELECT state, COUNT(*) AS location_count FROM government_services.service_locations GROUP BY state HAVING COUNT(*) > 2;

[User] Can you also show only those states that have at least one accessible location?

[Assistant] SELECT state, COUNT(*) AS location_count FROM government_services.service_locations WHERE state IN (SELECT DISTINCT state FROM government_services.service_locations WHERE is_accessible = TRUE) GROUP BY state HAVING COUNT(*) > 2;

[User] Now sort the results by location_count in descending order.

[Assistant] SELECT state, COUNT(*) AS location_count FROM government_services.service_locations WHERE state IN (SELECT DISTINCT state FROM government_services.service_locations WHERE is_accessible = TRUE) GROUP BY state HAVING COUNT(*) > 2 ORDER BY location_count DESC;

[User] What if I only want states where more than one third of locations are accessible? Show state, location_count, and accessible_location_count.

[Assistant] SELECT state, COUNT(*) AS location_count, SUM(CASE WHEN is_accessible = TRUE THEN 1 ELSE 0 END) AS accessible_location_count FROM government_services.service_locations GROUP BY state HAVING SUM(CASE WHEN is_accessible = TRUE THEN 1 ELSE 0 END) > COUNT(*)/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 narrative_info ( narrative text, top_3_coins text, price_change_percentage_1h numeric, price_change_percentage_24h numeric, price_change_percentage_7d numeric, market_cap numeric, volume_24h numeric, trend_rank numeric, token_num numeric )

[User] Which narratives have more than 20 tokens? Show the narrative, token number, and trend rank.

[Assistant] SELECT narrative, token_num, trend_rank FROM narrative_info WHERE token_num > 20;

[User] Add the 24-hour trading volume as well.

[Assistant] SELECT narrative, token_num, trend_rank, volume_24h FROM narrative_info WHERE token_num > 20;


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.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 )

[User] How many documents are there for each document_type? Show document_type and count ordered by the count in descending order.

[Assistant]
SELECT document_type,
       COUNT(*) AS count
FROM legal_services.documents
GROUP BY document_type
ORDER BY 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.doctors ( doctor_id text PRIMARY KEY, first_name text, last_name text, specialty text, license_number text, phone_number text, email text, hospital_affiliation_id text, created_at timestamp, updated_at timestamp )
CREATE TABLE healthcare.medical_records ( record_id.text, patient_id.text, appointment_id.text, doctor_id.text, record_date.timestamp, chief_complaint.text, present_illness_history.text, past_medical_history.text, physical_examination_notes.text, assessment.text, treatment_plan.text, vitals.json, created_at.timestamp )
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.medications ( medication_id text PRIMARY KEY, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )
CREATE TABLE healthcare.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )

[User] Show me the names and manufacturers of all medications whose description contains the word 'ointment'.

[Assistant]
SELECT medication_name, manufacturer
FROM healthcare.medications
WHERE description ILIKE '%ointment%';

[User] Also include the NDC code for each medication, and sort the result by medication_name ascending.

[Assistant]
SELECT medication_name, manufacturer, ndc_code
FROM healthcare.medications
WHERE description ILIKE '%ointment%'
ORDER BY medication_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 gaming_technology.players ( player_id uuid PRIMARY KEY, username text, email text, password_hash text, registration_date timestamptz, last_login timestamptz, country_code text, status text, profile_data jsonb )
CREATE TABLE gaming_technology.developers ( developer_id uuid PRIMARY KEY, name text, country text, founded_year int, website text, created_at timestamptz )

[User] List the usernames and countries for players who are located in a country where at least one developer is also registered.

[Assistant] SELECT username, country_code FROM gaming_technology.players WHERE country_code IN (SELECT country FROM gaming_technology.developers);


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 insurance.claim_documents (
    document_id character varying(64) NOT NULL, -- unique identifier for the document
    claim_id character varying(64) NOT NULL, -- identifier of the claim this document relates to (FK to claims)
    document_type character varying(50) NOT NULL, -- e.g., Police Report, Photo, Invoice, Medical Bill
    file_name character varying(255) NOT NULL, -- original name of the uploaded file
    file_path character varying(512) NOT NULL, -- storage path (e.g., S3 URL, network path)
    file_size_bytes integer, -- size of the file in bytes
    mime_type character varying(100), -- MIME type of the file (e.g., 'image/jpeg', 'application/pdf')
    uploaded_by character varying(64), -- identifier of the user/system who uploaded (FK to users/customers)
    uploaded_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- time of upload
    description text, -- optional description of the document
    PRIMARY KEY (document_id)
)

[User] For each document type, how many documents were uploaded by each user? Show the uploaded_by, document_type, and document count, ordered by document_type and count descending.

[Assistant]
SELECT uploaded_by, document_type, COUNT(*) AS document_count
FROM insurance.claim_documents
GROUP BY uploaded_by, document_type
ORDER BY document_type ASC, document_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 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 character varying(64) NOT NULL, user_id character varying(64) NOT NULL, wallet_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, order_type character varying(32) NOT NULL, quantity numeric(38,14) NOT NULL, price numeric(38,14) NOT NULL, status character varying(32) NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (order_id) )
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.dapps (
    dapp_id character varying(64) NOT NULL,  -- unique identifier for the DApp
    name character varying(128) NOT NULL, -- name of the DApp
    description text NOT NULL, -- description of the DApp
    url character varying(256) NOT NULL, -- URL of the DApp
    PRIMARY KEY (dapp_id)
)
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 PRIMARY KEY, 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 character varying(64) NOT NULL,  -- unique identifier for the notification
    user_id character varying(64) NOT NULL, -- identifier of the user receiving the notification
    message text NOT NULL, -- message of the notification
    sent_at timestamp NOT NULL, -- time when the notification was sent
    read_at timestamp, -- time when the notification was read
    PRIMARY KEY (notification_id)
)

[User] List all users who have pending orders for cryptocurrency assets, along with the asset_id and order quantity.

[Assistant] SELECT u.user_id, u.email, o.asset_id, o.quantity FROM trading_platform.users u JOIN trading_platform.orders o ON u.user_id = o.user_id JOIN trading_platform.metadata m ON o.asset_id = m.asset_id WHERE o.status = 'pending' AND m.key = 'asset_type' AND m.value = 'cryptocurrency';

[User] Now filter these results to only show orders created more than 3 days ago.

[Assistant] SELECT u.user_id, u.email, o.asset_id, o.quantity FROM trading_platform.users u JOIN trading_platform.orders o ON u.user_id = o.user_id JOIN trading_platform.metadata m ON o.asset_id = m.asset_id WHERE o.status = 'pending' AND m.key = 'asset_type' AND m.value = 'cryptocurrency' AND o.created_at <= NOW() - INTERVAL '3 days';

[User] Can you modify the query to also include the current price of these assets from the most recent trade?

[Assistant] SELECT u.user_id, u.email, o.asset_id, o.quantity, t.price AS current_price FROM trading_platform.users u JOIN trading_platform.orders o ON u.user_id = o.user_id JOIN trading_platform.metadata m ON o.asset_id = m.asset_id JOIN (SELECT asset_id, price, ROW_NUMBER() OVER (PARTITION BY asset_id ORDER BY traded_at DESC) AS rn FROM trading_platform.trades) t ON o.asset_id = t.asset_id AND t.rn = 1 WHERE o.status = 'pending' AND m.key = 'asset_type' AND m.value = 'cryptocurrency' AND o.created_at <= NOW() - INTERVAL '3 days';


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 gaming_technology.player_inventory (
    inventory_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an inventory entry
    player_id uuid NOT NULL, -- FK linking to the player owning the item
    item_id uuid NOT NULL, -- FK linking to the item definition
    quantity integer NOT NULL DEFAULT 1, -- number of items held (for stackable items)
    acquired_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the item was acquired
    instance_data jsonb, -- data specific to this instance (e.g., weapon mods, durability)
    PRIMARY KEY (inventory_id),
    -- Optional unique constraint if items are non-stackable or unique instances
    -- UNIQUE (player_id, item_id) -- Use if quantity is always 1
    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),
    -- FOREIGN KEY (item_id) REFERENCES gaming_technology.in_game_items(item_id)
)

[User] What is the count of unique items acquired on each day?

[Assistant] SELECT DATE(acquired_at) AS acquisition_date, COUNT(DISTINCT item_id) AS unique_item_count FROM gaming_technology.player_inventory GROUP BY DATE(acquired_at);

[User] Only show days where more than 10 unique items were acquired.

[Assistant] SELECT DATE(acquired_at) AS acquisition_date, COUNT(DISTINCT item_id) AS unique_item_count FROM gaming_technology.player_inventory GROUP BY DATE(acquired_at) HAVING COUNT(DISTINCT item_id) > 10;

[User] Also include the total quantity of items acquired on those days.

[Assistant] SELECT DATE(acquired_at) AS acquisition_date, COUNT(DISTINCT item_id) AS unique_item_count, SUM(quantity) AS total_quantity FROM gaming_technology.player_inventory GROUP BY DATE(acquired_at) HAVING COUNT(DISTINCT item_id) > 10;

[User] Order the results by the total quantity in descending order.

[Assistant] SELECT DATE(acquired_at) AS acquisition_date, COUNT(DISTINCT item_id) AS unique_item_count, SUM(quantity) AS total_quantity FROM gaming_technology.player_inventory GROUP BY DATE(acquired_at) HAVING COUNT(DISTINCT item_id) > 10 ORDER BY total_quantity 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.doctors ( doctor_id.text, first_name.text, last_name.text, specialty.text, license_number.text, phone_number.text, email.text, hospital_affiliation_id.text, created_at.timestamp, updated_at.timestamp )
CREATE TABLE healthcare.diagnoses ( diagnosis_id.text, 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.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.patient_insurance ( patient_insurance_id.text, 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] Find all patients who have both primary and non-primary insurance plans from the same provider, showing their patient IDs and provider details.

[Assistant] SELECT pi1.patient_id, pi1.plan_id, pi1.policy_number, pi1.is_primary FROM healthcare.patient_insurance pi1 JOIN healthcare.patient_insurance pi2 ON pi1.patient_id = pi2.patient_id AND pi1.plan_id = pi2.plan_id WHERE pi1.is_primary = TRUE AND pi2.is_primary = FALSE;

[User] Actually, I need to see only patients who have more than one non-primary insurance plan from the same provider.

[Assistant] SELECT pi1.patient_id, pi1.plan_id, COUNT(pi2.patient_insurance_id) AS non_primary_count FROM healthcare.patient_insurance pi1 JOIN healthcare.patient_insurance pi2 ON pi1.patient_id = pi2.patient_id AND pi1.plan_id = pi2.plan_id WHERE pi1.is_primary = TRUE AND pi2.is_primary = FALSE GROUP BY pi1.patient_id, pi1.plan_id HAVING COUNT(pi2.patient_insurance_id) > 1;

[User] Can you also include the expiration dates of these non-primary plans?

[Assistant] SELECT pi1.patient_id, pi1.plan_id, pi2.expiration_date, COUNT(pi2.patient_insurance_id) AS non_primary_count FROM healthcare.patient_insurance pi1 JOIN healthcare.patient_insurance pi2 ON pi1.patient_id = pi2.patient_id AND pi1.plan_id = pi2.plan_id WHERE pi1.is_primary = TRUE AND pi2.is_primary = FALSE GROUP BY pi1.patient_id, pi1.plan_id, pi2.expiration_date HAVING COUNT(pi2.patient_insurance_id) > 1;


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 text, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )

[User] I need to find all pairs of medications that share the same manufacturer. For each pair, show the first medication's ID and name, the second medication's ID and name, and the manufacturer.

[Assistant]
SELECT m1.medication_id AS med1_id,
       m1.medication_name AS med1_name,
       m2.medication_id AS med2_id,
       m2.medication_name AS med2_name,
       m1.manufacturer
FROM healthcare.medications m1
JOIN healthcare.medications m2
  ON m1.manufacturer = m2.manufacturer
 AND m1.medication_id < m2.medication_id;

[User] Actually, only include pairs where the two medications have different generic_name values.

[Assistant]
SELECT m1.medication_id AS med1_id,
       m1.medication_name AS med1_name,
       m2.medication_id AS med2_id,
       m2.medication_name AS med2_name,
       m1.manufacturer
FROM healthcare.medications m1
JOIN healthcare.medications m2
  ON m1.manufacturer = m2.manufacturer
 AND m1.medication_id < m2.medication_id
WHERE m1.generic_name <> m2.generic_name;

[User] Also, exclude any pairs where the manufacturer field is NULL for either medication.

[Assistant]
SELECT m1.medication_id AS med1_id,
       m1.medication_name AS med1_name,
       m2.medication_id AS med2_id,
       m2.medication_name AS med2_name,
       m1.manufacturer
FROM healthcare.medications m1
JOIN healthcare.medications m2
  ON m1.manufacturer = m2.manufacturer
 AND m1.medication_id < m2.medication_id
WHERE m1.generic_name <> m2.generic_name
  AND m1.manufacturer IS NOT NULL
  AND m2.manufacturer IS NOT NULL;

[User] Finally, limit the result to manufacturers that have at least three medications in the table.

[Assistant]
SELECT m1.medication_id AS med1_id,
       m1.medication_name AS med1_name,
       m2.medication_id AS med2_id,
       m2.medication_name AS med2_name,
       m1.manufacturer
FROM healthcare.medications m1
JOIN healthcare.medications m2
  ON m1.manufacturer = m2.manufacturer
 AND m1.medication_id < m2.medication_id
WHERE m1.generic_name <> m2.generic_name
  AND m1.manufacturer IS NOT NULL
  AND m2.manufacturer IS NOT NULL
  AND m1.manufacturer IN (
      SELECT manufacturer
      FROM healthcare.medications
      WHERE manufacturer IS NOT NULL
      GROUP BY manufacturer
      HAVING COUNT(*) >= 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 smart_money_profit ( address character varying(100) NOT NULL, rank INT, profit numeric(38,6), roi numeric(38,2), realized_ratio numeric(38,2), most_profit_token character varying(100), last_trade_time character varying(100), chain character varying(100) )
CREATE TABLE smart_money_token_inflow ( token_address text, token_symbol text, token_amount numeric, usd_value numeric, avg_price numeric, type numeric, address_amount numeric, narrative text, chain text )

[User] Show me the top 5 smart money addresses by profit on the Ethereum chain, along with their most profitable token and ROI, but only include addresses with a realized profit ratio above 80%.

[Assistant] SELECT address, most_profit_token, roi FROM smart_money_profit WHERE chain = 'Ethereum' AND realized_ratio > 80 ORDER BY profit DESC LIMIT 5;

[User] Can you also include the last trade time for these addresses and filter to only show results with ROI greater than 100%?

[Assistant] SELECT address, most_profit_token, roi, last_trade_time FROM smart_money_profit WHERE chain = 'Ethereum' AND realized_ratio > 80 AND roi > 100 ORDER BY profit DESC LIMIT 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.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;