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_basic_info ( coin_id character varying(100) NOT NULL, -- the id of the token token_name character varying(100) NOT NULL, -- the token's name token_symbol character varying(100) NOT NULL, -- the token's symbol token_address character varying(100) NOT NULL, -- the token's address chain text, -- the chain that the token resides price double precision, -- the current price of the token price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days highest_price_24h double precision, -- the highest price of the token in 24 hours lowest_price_24h double precision,  -- the lowest price of the token in 24 hours market_cap double precision, -- the market cap of the token market_cap_rank bigint, -- the rank of the token market cap in desc market_cap_change_percentage_24h text, -- the percentage of market cap changes in 24 hours total_volume text, -- the trade volum of the token both in decentralized exchange(DEX) and centralized exchange(CEX) narrative text, -- the category or narrative of the token trend_rank biging, -- the trending rank of the token, value 1 expresses the most popular token. ,PRIMARY KEY (coin_id, chain) )
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 token_dexpool_info ( pair_address character varying(512) NOT NULL, -- the id of dexpool token_name character varying(100) NOT NULL, -- the name of the token in the dexpool token_symbol character varying(100) NOT NULL, -- the token's symbol chain text, -- the chain that the dexpool resides price double precision, -- the current price of the token price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour price_change_percentage_6h double precision, -- change in value divided by the absolute price value of the original token price in 6 hours price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours makers_24h double precision, -- the makers of the dex pool in 24 hours volume_24h double precision, -- the trade volume of the dex pool in 24 hours liquidity double precision, -- the liquidity of the dex pool market_cap double precision, -- the market cap of the token trend_rank bigint, -- the rank of token in the dex pool of recent trending, value 1 expresses the most popular token. ,PRIMARY KEY (pair_address, chain) )
CREATE TABLE smart_money_token_performance ( token_address character varying(100) NOT NULL, -- the token's address token_symbol character varying(100), -- the tokens's symbol pnl numeric(38,2), -- the profit users made on this token net_flow numeric(38,2), -- the netflow of the token, means the money user spent minus the the money user sold of this token avg_cost numeric(38,16), -- the average cost price of user spent on this token price double precision, -- the current price of the token realized_ratio numeric(10,2), -- the ratio user sold of the token roi numeric(10,2), -- the roi users made of this token chain character varying(100), -- the chain that the token resides PRIMARY KEY (token_address, chain) )

[User] Which narratives saw the highest average net flow from smart money performance this year, and what is the average roi for those narratives along with the total number of tokens in each?

[Assistant]
SELECT tbi.narrative, AVG(smtp.net_flow) AS avg_net_flow, AVG(smtp.roi) AS avg_roi, COUNT(DISTINCT smtp.token_address) AS token_count
FROM smart_money_token_performance smtp
JOIN token_basic_info tbi ON smtp.token_address = tbi.token_address AND smtp.chain = tbi.chain
WHERE DATE_PART('year', CURRENT_DATE) = DATE_PART('year', CURRENT_DATE)
GROUP BY tbi.narrative
ORDER BY avg_net_flow DESC;

[User] Could you restrict the results to only those narratives with an average net flow above 5000 and an average roi greater than 0.3?

[Assistant]
SELECT tbi.narrative, AVG(smtp.net_flow) AS avg_net_flow, AVG(smtp.roi) AS avg_roi, COUNT(DISTINCT smtp.token_address) AS token_count
FROM smart_money_token_performance smtp
JOIN token_basic_info tbi ON smtp.token_address = tbi.token_address AND smtp.chain = tbi.chain
GROUP BY tbi.narrative
HAVING AVG(smtp.net_flow) > 5000 AND AVG(smtp.roi) > 0.3
ORDER BY avg_net_flow DESC;

[User] Actually, please also include the total pnl for each narrative in the output.

[Assistant]
SELECT tbi.narrative, AVG(smtp.net_flow) AS avg_net_flow, AVG(smtp.roi) AS avg_roi, SUM(smtp.pnl) AS total_pnl, COUNT(DISTINCT smtp.token_address) AS token_count
FROM smart_money_token_performance smtp
JOIN token_basic_info tbi ON smtp.token_address = tbi.token_address AND smtp.chain = tbi.chain
GROUP BY tbi.narrative
HAVING AVG(smtp.net_flow) > 5000 AND AVG(smtp.roi) > 0.3
ORDER BY avg_net_flow DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.transactions ( transaction_id text, account_id text, related_account_id text, transaction_type text, amount numeric, currency text, transaction_date timestamp, effective_date date, description text, status text, reference_number text )
CREATE TABLE financial_services.securities ( security_id.text, ticker_symbol.text, isin_code.text, cusip_code.text, security_name.text, security_type.text, exchange.text, currency.text, issuer_name.text, sector.text, last_updated.timestamp )
CREATE TABLE financial_services.market_data ( data_point_id bigserial NOT NULL, security_id character varying(64) NOT NULL, data_timestamp timestamp NOT NULL, open_price numeric(19, 8), high_price numeric(19, 8), low_price numeric(19, 8), close_price numeric(19, 8) NOT NULL, adjusted_close_price numeric(19, 8), volume bigint, source character varying(50), PRIMARY KEY (data_point_id), UNIQUE (security_id, data_timestamp), FOREIGN KEY (security_id) REFERENCES financial_services.securities(security_id) )
CREATE TABLE financial_services.loans ( loan_id text, account_id text, loan_type text, principal_amount numeric, current_principal_balance numeric, interest_rate numeric, term_months integer, origination_date date, maturity_date date, monthly_payment numeric, collateral_description text, status text )

[User] For each loan, show the loan_id, the account_id, the principal_amount, and the ticker_symbol and security_name of any associated collateral, if the collateral_description matches a security's ticker_symbol.

[Assistant]
SELECT l.loan_id, l.account_id, l.principal_amount, s.ticker_symbol, s.security_name
FROM financial_services.loans l
LEFT JOIN financial_services.securities s
  ON l.collateral_description = s.ticker_symbol;

[User] Actually, please only include loans where a matching collateral security exists.

[Assistant]
SELECT l.loan_id, l.account_id, l.principal_amount, s.ticker_symbol, s.security_name
FROM financial_services.loans l
JOIN financial_services.securities s
  ON l.collateral_description = s.ticker_symbol;

[User] Add the security's sector and filter to only include loans with principal_amount over 20000.

[Assistant]
SELECT l.loan_id, l.account_id, l.principal_amount, s.ticker_symbol, s.security_name, s.sector
FROM financial_services.loans l
JOIN financial_services.securities s
  ON l.collateral_description = s.ticker_symbol
WHERE l.principal_amount > 20000;

[User] Sort the result by principal_amount descending.

[Assistant]
SELECT l.loan_id, l.account_id, l.principal_amount, s.ticker_symbol, s.security_name, s.sector
FROM financial_services.loans l
JOIN financial_services.securities s
  ON l.collateral_description = s.ticker_symbol
WHERE l.principal_amount > 20000
ORDER BY l.principal_amount DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.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 text, account_id text, related_account_id text, transaction_type text, amount numeric, currency text, transaction_date timestamp, effective_date date, description text, status text, reference_number text )
CREATE TABLE financial_services.securities ( security_id.text, ticker_symbol.text, isin_code.text, cusip_code.text, security_name.text, security_type.text, exchange.text, currency.text, issuer_name.text, sector.text, last_updated.timestamp )
CREATE TABLE financial_services.trades ( trade_id character varying(64) NOT NULL, account_id character varying(64) NOT NULL, security_id character varying(64) NOT NULL, order_id character varying(64), trade_type character varying(10) NOT NULL, quantity numeric(19, 8) NOT NULL, price_per_unit numeric(19, 8) NOT NULL, total_amount numeric(19, 4) NOT NULL, commission numeric(10, 4), trade_timestamp timestamp NOT NULL, settlement_date date, status character varying(32) NOT NULL, execution_venue character varying(100), PRIMARY KEY (trade_id), FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id), FOREIGN KEY (security_id) REFERENCES financial_services.securities(security_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.loans ( loan_id text, account_id text, loan_type text, principal_amount numeric, current_principal_balance numeric, interest_rate numeric, term_months integer, origination_date date, maturity_date date, monthly_payment numeric, collateral_description text, status text )

[User] Can you show me, for each account type, the total transaction amount and the number of transactions, including the customer full name for each account type?

[Assistant]
SELECT a.account_type, c.first_name || ' ' || c.last_name AS customer_name, SUM(t.amount) AS total_transaction_amount, COUNT(t.transaction_id) AS transaction_count
FROM financial_services.accounts a
JOIN financial_services.customers c ON a.customer_id = c.customer_id
JOIN financial_services.transactions t ON a.account_id = t.account_id
GROUP BY a.account_type, customer_name;

[User] Actually, could you only include accounts where the balance is greater than 5000?

[Assistant]
SELECT a.account_type, c.first_name || ' ' || c.last_name AS customer_name, SUM(t.amount) AS total_transaction_amount, COUNT(t.transaction_id) AS transaction_count
FROM financial_services.accounts a
JOIN financial_services.customers c ON a.customer_id = c.customer_id
JOIN financial_services.transactions t ON a.account_id = t.account_id
WHERE a.balance > 5000
GROUP BY a.account_type, customer_name;

[User] Can you also filter transactions to only include those with status 'SUCCESSFUL'?

[Assistant]
SELECT a.account_type, c.first_name || ' ' || c.last_name AS customer_name, SUM(t.amount) AS total_transaction_amount, COUNT(t.transaction_id) AS transaction_count
FROM financial_services.accounts a
JOIN financial_services.customers c ON a.customer_id = c.customer_id
JOIN financial_services.transactions t ON a.account_id = t.account_id
WHERE a.balance > 5000 AND t.status = 'SUCCESSFUL'
GROUP BY a.account_type, customer_name;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE 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.staff ( staff_id.text, property_id.text, first_name.text, last_name.text, position.text, work_email.text, work_phone.text, hire_date.date, termination_date.date, is_active.boolean, access_level.integer, manager_id.text, created_at.timestamp )
CREATE TABLE hospitality_technology.services ( service_id.text, property_id.text, service_name.text, description.text, category.text, price.numeric, unit.text, is_available.boolean, department.text )
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 )
CREATE TABLE hospitality_technology.payments ( payment_id.text, reservation_id.text, guest_id.text, bill_id.text, amount.numeric, currency_code.text, payment_method.text, card_type.text, card_last_four.text, transaction_ref.text, payment_timestamp.timestamp, status.text, staff_id_processed.text, notes.text )

[User] List all guests who have placed service orders for services in the 'Transportation' department, along with their full names and the service names.

[Assistant]
SELECT g.guest_id, g.first_name, g.last_name, s.service_name
FROM hospitality_technology.guests g
JOIN hospitality_technology.service_orders so ON g.guest_id = so.guest_id
JOIN hospitality_technology.services s ON so.service_id = s.service_id
WHERE s.department = 'Transportation';

[User] Actually, only include guests who have placed at least two such service orders. Also, order the results by the guest's last name.

[Assistant]
SELECT g.guest_id, g.first_name, g.last_name, COUNT(so.order_id) AS order_count
FROM hospitality_technology.guests g
JOIN hospitality_technology.service_orders so ON g.guest_id = so.guest_id
JOIN hospitality_technology.services s ON so.service_id = s.service_id
WHERE s.department = 'Transportation'
GROUP BY g.guest_id, g.first_name, g.last_name
HAVING COUNT(so.order_id) >= 2
ORDER BY g.last_name ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.patients (
    patient_id character varying(64) NOT NULL,  -- unique identifier for the patient
    first_name character varying(100) NOT NULL, -- patient's first name
    last_name character varying(100) NOT NULL, -- patient's last name
    date_of_birth date NOT NULL, -- patient's date of birth
    gender character varying(10), -- patient's gender (e.g., Male, Female, Other)
    address text, -- patient's home address
    phone_number character varying(20), -- patient's phone number
    email character varying(128) UNIQUE, -- patient's email address
    emergency_contact_name character varying(200), -- name of emergency contact
    emergency_contact_phone character varying(20), -- phone number of emergency contact
    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record creation time
    updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record last update time
    PRIMARY KEY (patient_id)
)
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.patient_insurance (
    patient_insurance_id character varying(64) NOT NULL, -- unique identifier for this patient-plan link
    patient_id character varying(64) NOT NULL, -- FK to patients table
    plan_id character varying(64) NOT NULL, -- FK to insurance_plans table
    policy_number character varying(100) NOT NULL, -- patient's policy number
    group_number character varying(100), -- group number, if applicable
    subscriber_name character varying(200), -- name of the primary policy holder
    effective_date date NOT NULL, -- date the coverage begins
    expiration_date date, -- date the coverage ends (if known)
    is_primary boolean NOT NULL DEFAULT true, -- indicates if this is the primary insurance
    PRIMARY KEY (patient_insurance_id),
    UNIQUE (patient_id, plan_id, policy_number) -- ensure a patient doesn't have the same policy twice
)

[User] For each patient, show their full name and the count of insurance plans they are enrolled in, as well as their earliest policy effective date.

[Assistant]
SELECT p.first_name, p.last_name, COUNT(pi.plan_id) AS plan_count, MIN(pi.effective_date) AS earliest_effective_date
FROM healthcare.patients p
JOIN healthcare.patient_insurance pi ON p.patient_id = pi.patient_id
GROUP BY p.patient_id, p.first_name, p.last_name;

[User] Only include patients with more than one insurance plan.

[Assistant]
SELECT p.first_name, p.last_name, COUNT(pi.plan_id) AS plan_count, MIN(pi.effective_date) AS earliest_effective_date
FROM healthcare.patients p
JOIN healthcare.patient_insurance pi ON p.patient_id = pi.patient_id
GROUP BY p.patient_id, p.first_name, p.last_name
HAVING COUNT(pi.plan_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.medical_records (
    record_id character varying(64) NOT NULL,  -- unique identifier for the medical record entry
    patient_id character varying(64) NOT NULL, -- FK to patients table
    appointment_id character varying(64) UNIQUE, -- FK to appointments table (can be null if record not tied to specific appt)
    doctor_id character varying(64) NOT NULL, -- FK to doctors table (doctor creating the record)
    record_date timestamp with time zone NOT NULL, -- date the record/observation was made
    chief_complaint text, -- patient's primary reason for visit
    present_illness_history text, -- detailed history of the current issue
    past_medical_history text, -- relevant past conditions/surgeries
    physical_examination_notes text, -- findings from the physical exam
    assessment text, -- doctor's assessment/diagnosis summary
    treatment_plan text, -- planned course of action
    vitals jsonb, -- store vitals like BP, HR, Temp as structured JSON
    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
    PRIMARY KEY (record_id)
)

[User] I would like to see a list of all medical records where the chief complaint contains the word 'cough' along with the doctor's ID and the date of the record.

[Assistant] SELECT record_id, doctor_id, record_date, chief_complaint FROM healthcare.medical_records WHERE chief_complaint ILIKE '%cough%';

[User] Could you expand this to show only records where the temperature in the vitals field is above 37.5°C?

[Assistant] SELECT record_id, doctor_id, record_date, chief_complaint, vitals->>'temperature' AS temperature FROM healthcare.medical_records WHERE chief_complaint ILIKE '%cough%' AND (vitals->>'temperature')::float > 37.5;

[User] Now, restrict it further to only show records documented after January 1st, 2024.

[Assistant] SELECT record_id, doctor_id, record_date, chief_complaint, vitals->>'temperature' AS temperature FROM healthcare.medical_records WHERE chief_complaint ILIKE '%cough%' AND (vitals->>'temperature')::float > 37.5 AND record_date >= '2024-01-01';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.accounts ( account_id text PRIMARY KEY, customer_id text, account_number text, account_type text, balance numeric, currency text, opened_date date, status text, interest_rate numeric, last_updated_at timestamp )
CREATE TABLE financial_services.transactions ( transaction_id text PRIMARY KEY, account_id text, related_account_id text, transaction_type text, amount numeric, currency text, transaction_date timestamp, effective_date date, description text, status text, reference_number text )
CREATE TABLE financial_services.trades ( trade_id text PRIMARY KEY, account_id text, security_id text, order_id text, trade_type text, quantity numeric, price_per_unit numeric, total_amount numeric, commission numeric, trade_timestamp timestamp, settlement_date date, status text, execution_venue text )
CREATE TABLE financial_services.market_data ( data_point_id bigserial PRIMARY KEY, security_id text, data_timestamp timestamp, open_price numeric, high_price numeric, low_price numeric, close_price numeric, adjusted_close_price numeric, volume bigint, source text )
CREATE TABLE financial_services.employees ( employee_id text PRIMARY KEY, first_name text, last_name text, job_title text, department text, branch_id text, email text, phone_extension text, hire_date date, termination_date date, manager_id text, status text )

[User] Can you provide a list of all trades in the past 90 days, including the security_id, account_id, trade_type, quantity, total_amount, and the current balance of the involved account?

[Assistant]
SELECT t.trade_id, t.security_id, t.account_id, t.trade_type, t.quantity, t.total_amount, a.balance
FROM financial_services.trades t
JOIN financial_services.accounts a ON t.account_id = a.account_id
WHERE t.trade_timestamp >= NOW() - INTERVAL '90 days';

[User] Please also include the execution venue for each trade in the result.

[Assistant]
SELECT t.trade_id, t.security_id, t.account_id, t.trade_type, t.quantity, t.total_amount, t.execution_venue, a.balance
FROM financial_services.trades t
JOIN financial_services.accounts a ON t.account_id = a.account_id
WHERE t.trade_timestamp >= NOW() - INTERVAL '90 days';

[User] Now, only show trades where the total_amount is above 10000.

[Assistant]
SELECT t.trade_id, t.security_id, t.account_id, t.trade_type, t.quantity, t.total_amount, t.execution_venue, a.balance
FROM financial_services.trades t
JOIN financial_services.accounts a ON t.account_id = a.account_id
WHERE t.trade_timestamp >= NOW() - INTERVAL '90 days'
  AND t.total_amount > 10000;

[User] Finally, order the output by trade_timestamp descending.

[Assistant]
SELECT t.trade_id, t.security_id, t.account_id, t.trade_type, t.quantity, t.total_amount, t.execution_venue, a.balance
FROM financial_services.trades t
JOIN financial_services.accounts a ON t.account_id = a.account_id
WHERE t.trade_timestamp >= NOW() - INTERVAL '90 days'
  AND t.total_amount > 10000
ORDER BY t.trade_timestamp 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 hospitality_technology.service_orders ( order_id text PRIMARY KEY, reservation_id text, guest_id text, service_id text, staff_id_ordered text, staff_id_delivered text, order_timestamp timestamp, delivery_timestamp timestamp, quantity int, unit_price numeric, total_price numeric, status text, notes text, bill_id text )

[User] Show me the total quantity and total revenue for each service, along with the number of unique guests who ordered each service.

[Assistant] SELECT service_id, SUM(quantity) AS total_quantity, SUM(total_price) AS total_revenue, COUNT(DISTINCT guest_id) AS unique_guest_count FROM hospitality_technology.service_orders GROUP BY service_id;

[User] Now, only include services where the total revenue is above 1000 and sort by total_revenue descending.

[Assistant] SELECT service_id, SUM(quantity) AS total_quantity, SUM(total_price) AS total_revenue, COUNT(DISTINCT guest_id) AS unique_guest_count FROM hospitality_technology.service_orders GROUP BY service_id HAVING SUM(total_price) > 1000 ORDER BY total_revenue 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 NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the player
    username character varying(100) NOT NULL UNIQUE, -- player's chosen display name
    email character varying(255) NOT NULL UNIQUE, -- player's email address for login/recovery
    password_hash text NOT NULL, -- securely hashed password
    registration_date timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the player account was created
    last_login timestamp with time zone, -- timestamp of the last successful login
    country_code character(2), -- player's country (ISO 3166-1 alpha-2)
    status character varying(20) NOT NULL DEFAULT 'active', -- account status (e.g., active, banned, suspended)
    profile_data jsonb, -- flexible field for avatar url, bio, preferences etc.
    PRIMARY KEY (player_id)
)
CREATE TABLE gaming_technology.games ( game_id uuid PRIMARY KEY, title text, developer_id uuid, publisher_id uuid, genre text, release_date date, description text, platform text, engine text, website text )
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.player_inventory ( inventory_id.uuid, player_id.uuid, item_id.uuid, quantity.integer, acquired_at.timestamptz, instance_data.jsonb )

[User] Find the average session duration in minutes for players from each country.

[Assistant] SELECT p.country_code, AVG(gs.duration_seconds) / 60 AS avg_duration_minutes FROM gaming_technology.players p JOIN gaming_technology.game_sessions gs ON p.player_id = gs.player_id WHERE p.country_code IS NOT NULL GROUP BY p.country_code;

[User] Filter the results to only include countries where the average session duration is more than 30 minutes.

[Assistant] SELECT p.country_code, AVG(gs.duration_seconds) / 60 AS avg_duration_minutes FROM gaming_technology.players p JOIN gaming_technology.game_sessions gs ON p.player_id = gs.player_id WHERE p.country_code IS NOT NULL GROUP BY p.country_code HAVING AVG(gs.duration_seconds) / 60 > 30;

[User] Include the total number of players from each of these countries in the result.

[Assistant] SELECT p.country_code, AVG(gs.duration_seconds) / 60 AS avg_duration_minutes, COUNT(DISTINCT p.player_id) AS player_count FROM gaming_technology.players p JOIN gaming_technology.game_sessions gs ON p.player_id = gs.player_id WHERE p.country_code IS NOT NULL GROUP BY p.country_code HAVING AVG(gs.duration_seconds) / 60 > 30;

[User] Order the final list by player count in descending order.

[Assistant] SELECT p.country_code, AVG(gs.duration_seconds) / 60 AS avg_duration_minutes, COUNT(DISTINCT p.player_id) AS player_count FROM gaming_technology.players p JOIN gaming_technology.game_sessions gs ON p.player_id = gs.player_id WHERE p.country_code IS NOT NULL GROUP BY p.country_code HAVING AVG(gs.duration_seconds) / 60 > 30 ORDER BY player_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 government_services.citizens ( citizen_id.text, national_id_number.text, first_name.text, last_name.text, date_of_birth.date, gender.text, primary_address.text, contact_email.text, contact_phone.text, registration_date.timestamp, is_verified.boolean )
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.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.employees ( employee_id.text, agency_id.text, first_name.text, last_name.text, job_title.text, department.text, work_email.text, work_phone.text, hire_date.date, termination_date.date, access_level.text, manager_employee_id.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] Count the total number of employees who have a direct manager assigned.

[Assistant] SELECT COUNT(employee_id) FROM government_services.employees WHERE manager_employee_id IS NOT NULL;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.prescriptions ( prescription_id character varying(64) NOT NULL, record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, medication_id character varying(64) NOT NULL, dosage character varying(100) NOT NULL, frequency character varying(100) NOT NULL, route character varying(50), start_date date NOT NULL, end_date date, quantity_dispensed numeric(10,2), refills_allowed integer NOT NULL DEFAULT 0, prescription_date timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (prescription_id) )
CREATE TABLE healthcare.insurance_plans ( plan_id character varying(64) NOT NULL, plan_name character varying(200) NOT NULL, insurance_provider character varying(100) NOT NULL, plan_type character varying(50), contact_phone character varying(20), website character varying(255), PRIMARY KEY (plan_id) )
CREATE TABLE healthcare.patient_insurance (
    patient_insurance_id character varying(64) NOT NULL, -- unique identifier for this patient-plan link
    patient_id character varying(64) NOT NULL, -- FK to patients table
    plan_id character varying(64) NOT NULL, -- FK to insurance_plans table
    policy_number character varying(100) NOT NULL, -- patient's policy number
    group_number character varying(100), -- group number, if applicable
    subscriber_name character varying(200), -- name of the primary policy holder
    effective_date date NOT NULL, -- date the coverage begins
    expiration_date date, -- date the coverage ends (if known)
    is_primary boolean NOT NULL DEFAULT true, -- indicates if this is the primary insurance
    PRIMARY KEY (patient_insurance_id),
    UNIQUE (patient_id, plan_id, policy_number) -- ensure a patient doesn't have the same policy twice
)

[User] List prescription_id, policy_number, plan_name, and quantity_dispensed for all ongoing prescriptions (end_date IS NULL) where the associated insurance plan_type is 'PPO'.

[Assistant]
SELECT p.prescription_id,
       pi.policy_number,
       ip.plan_name,
       p.quantity_dispensed
FROM healthcare.prescriptions p
JOIN healthcare.patient_insurance pi
  ON p.patient_id = pi.patient_id
JOIN healthcare.insurance_plans ip
  ON pi.plan_id = ip.plan_id
WHERE p.end_date IS NULL
  AND ip.plan_type = 'PPO';


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.text, medication_name.text, generic_name.text, manufacturer.text, ndc_code.text, description.text )
CREATE TABLE healthcare.prescriptions ( prescription_id.text, record_id.text, patient_id.text, doctor_id.text, medication_id.text, dosage.text, frequency.text, route.text, start_date.date, end_date.date, quantity_dispensed.numeric, refills_allowed.integer, prescription_date.timestamp )
CREATE TABLE healthcare.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )
CREATE TABLE healthcare.patient_insurance ( patient_insurance_id.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] List each doctor and the total number of unique patients for appointments that have been completed. Return doctor_id, first_name, last_name, and patient_count.

[Assistant]
SELECT d.doctor_id,
       d.first_name,
       d.last_name,
       COUNT(DISTINCT a.patient_id) AS patient_count
FROM healthcare.doctors d
JOIN healthcare.appointments a
  ON d.doctor_id = a.doctor_id
WHERE a.status = 'Completed'
GROUP BY d.doctor_id, d.first_name, d.last_name;

[User] Only include doctors whose patient_count is greater than 10.

[Assistant]
SELECT d.doctor_id,
       d.first_name,
       d.last_name,
       COUNT(DISTINCT a.patient_id) AS patient_count
FROM healthcare.doctors d
JOIN healthcare.appointments a
  ON d.doctor_id = a.doctor_id
WHERE a.status = 'Completed'
GROUP BY d.doctor_id, d.first_name, d.last_name
HAVING COUNT(DISTINCT a.patient_id) > 10;

[User] Also include the average duration of those completed appointments as avg_duration.

[Assistant]
SELECT d.doctor_id,
       d.first_name,
       d.last_name,
       COUNT(DISTINCT a.patient_id) AS patient_count,
       AVG(a.duration_minutes) AS avg_duration
FROM healthcare.doctors d
JOIN healthcare.appointments a
  ON d.doctor_id = a.doctor_id
WHERE a.status = 'Completed'
GROUP BY d.doctor_id, d.first_name, d.last_name
HAVING COUNT(DISTINCT a.patient_id) > 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 financial_services.customers ( customer_id text PRIMARY KEY, first_name text, last_name text, date_of_birth date, ssn_hash text, address text, city text, state text, zip_code text, country text, email text, phone_number text, created_at timestamp, status text, risk_profile text )
CREATE TABLE financial_services.accounts ( account_id 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.securities (
    security_id character varying(64) NOT NULL, -- unique identifier for the security
    ticker_symbol character varying(20) NOT NULL UNIQUE, -- stock ticker or fund symbol
    isin_code character varying(12) UNIQUE, -- International Securities Identification Number
    cusip_code character varying(9) UNIQUE, -- CUSIP number
    security_name text NOT NULL, -- full name of the security
    security_type character varying(50) NOT NULL, -- e.g., Stock, Bond, ETF, Mutual Fund, Option, Future
    exchange character varying(50), -- primary exchange where traded (e.g., NYSE, NASDAQ)
    currency character varying(3) NOT NULL, -- currency the security is denominated in
    issuer_name character varying(255), -- name of the issuing entity
    sector character varying(100), -- industry sector
    last_updated timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (security_id)
)
CREATE TABLE financial_services.trades ( trade_id.text, account_id.text, security_id.text, order_id.text, trade_type.text, quantity.numeric, price_per_unit.numeric, total_amount.numeric, commission.numeric, trade_timestamp.timestamp, settlement_date.date, status.text, execution_venue.text )
CREATE TABLE financial_services.market_data ( data_point_id bigint, security_id text, data_timestamp timestamp, open_price numeric, high_price numeric, low_price numeric, close_price numeric, adjusted_close_price numeric, volume bigint, source text )
CREATE TABLE financial_services.employees ( employee_id text, first_name text, last_name text, job_title text, department text, branch_id text, email text, phone_extension text, hire_date date, termination_date date, manager_id text, status text )
CREATE TABLE financial_services.loans ( loan_id text, account_id text, loan_type text, principal_amount numeric, current_principal_balance numeric, interest_rate numeric, term_months integer, origination_date date, maturity_date date, monthly_payment numeric, collateral_description text, status text )

[User] Show me the total traded volume and the average price per security for trades executed last month.

[Assistant]
SELECT s.ticker_symbol,
       SUM(t.quantity) AS total_volume,
       AVG(t.price_per_unit) AS avg_price
FROM financial_services.trades t
JOIN financial_services.securities s ON t.security_id = s.security_id
WHERE t.trade_timestamp >= date_trunc('month', CURRENT_DATE - INTERVAL '1 month')
  AND t.trade_timestamp < date_trunc('month', CURRENT_DATE)
GROUP BY s.ticker_symbol;

[User] Filter to only include those trades with status 'SETTLED' and execution_venue 'NYSE'.

[Assistant]
SELECT s.ticker_symbol,
       SUM(t.quantity) AS total_volume,
       AVG(t.price_per_unit) AS avg_price
FROM financial_services.trades t
JOIN financial_services.securities s ON t.security_id = s.security_id
WHERE t.trade_timestamp >= date_trunc('month', CURRENT_DATE - INTERVAL '1 month')
  AND t.trade_timestamp < date_trunc('month', CURRENT_DATE)
  AND t.status = 'SETTLED'
  AND t.execution_venue = 'NYSE'
GROUP BY s.ticker_symbol;

[User] Now exclude any securities where the summed quantity is less than 1000.

[Assistant]
SELECT s.ticker_symbol,
       SUM(t.quantity) AS total_volume,
       AVG(t.price_per_unit) AS avg_price
FROM financial_services.trades t
JOIN financial_services.securities s ON t.security_id = s.security_id
WHERE t.trade_timestamp >= date_trunc('month', CURRENT_DATE - INTERVAL '1 month')
  AND t.trade_timestamp < date_trunc('month', CURRENT_DATE)
  AND t.status = 'SETTLED'
  AND t.execution_venue = 'NYSE'
GROUP BY s.ticker_symbol
HAVING SUM(t.quantity) >= 1000;


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.post_hashtags ( post_hashtag_id character varying(64) NOT NULL, post_id character varying(64) NOT NULL, hashtag_id character varying(64) NOT NULL, PRIMARY KEY (post_hashtag_id), CONSTRAINT unique_post_hashtag UNIQUE (post_id, hashtag_id) )
CREATE TABLE social_media.user_settings ( setting_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL UNIQUE, theme character varying(20) DEFAULT 'light', email_notifications_enabled boolean DEFAULT true, push_notifications_enabled boolean DEFAULT true, private_profile boolean DEFAULT false, updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (setting_id) )

[User] How many users currently have their profile set to private?

[Assistant] SELECT COUNT(*) FROM social_media.user_settings WHERE private_profile = true;


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

[User] Provide a summary of transactions by transaction_type, showing the count and the total amount for each type.

[Assistant] SELECT transaction_type, COUNT(transaction_id) AS transaction_count, SUM(amount) AS total_amount FROM financial_services.transactions GROUP BY transaction_type;

[User] Please restrict this summary to include only transactions that occurred within the last 6 months.

[Assistant] SELECT transaction_type, COUNT(transaction_id) AS transaction_count, SUM(amount) AS total_amount FROM financial_services.transactions WHERE transaction_date >= NOW() - INTERVAL '6 months' GROUP BY transaction_type;

[User] Additionally, only show transaction types where the total amount is greater than 5000.

[Assistant] SELECT transaction_type, COUNT(transaction_id) AS transaction_count, SUM(amount) AS total_amount FROM financial_services.transactions WHERE transaction_date >= NOW() - INTERVAL '6 months' GROUP BY transaction_type HAVING SUM(amount) > 5000;


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.hashtags (
    hashtag_id character varying(64) NOT NULL, -- unique identifier for the hashtag
    tag_name character varying(100) NOT NULL UNIQUE, -- the actual hashtag text (without '#')
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when the hashtag was first used
    PRIMARY KEY (hashtag_id)
)

[User] Can you provide all pairs of hashtags created on the same date, including both hashtag_id values and their creation timestamps?

[Assistant]
SELECT h1.hashtag_id AS hashtag1, h2.hashtag_id AS hashtag2, h1.created_at AS time1, h2.created_at AS time2
FROM social_media.hashtags h1
JOIN social_media.hashtags h2
  ON DATE(h1.created_at) = DATE(h2.created_at)
WHERE h1.hashtag_id < h2.hashtag_id;

[User] Actually, only include pairs where the time difference between their creation timestamps is less than 2 hours.

[Assistant]
SELECT h1.hashtag_id AS hashtag1, h2.hashtag_id AS hashtag2, h1.created_at AS time1, h2.created_at AS time2
FROM social_media.hashtags h1
JOIN social_media.hashtags h2
  ON DATE(h1.created_at) = DATE(h2.created_at)
WHERE h1.hashtag_id < h2.hashtag_id
  AND ABS(EXTRACT(EPOCH FROM (h1.created_at - h2.created_at))) < 7200;

[User] Now order the results by the earlier of the two creation timestamps in descending order.

[Assistant]
SELECT h1.hashtag_id AS hashtag1, h2.hashtag_id AS hashtag2, h1.created_at AS time1, h2.created_at AS time2
FROM social_media.hashtags h1
JOIN social_media.hashtags h2
  ON DATE(h1.created_at) = DATE(h2.created_at)
WHERE h1.hashtag_id < h2.hashtag_id
  AND ABS(EXTRACT(EPOCH FROM (h1.created_at - h2.created_at))) < 7200
ORDER BY LEAST(h1.created_at, h2.created_at) DESC;

[User] Finally, only show pairs where both tag names begin with the same first letter.

[Assistant]
SELECT h1.hashtag_id AS hashtag1, h2.hashtag_id AS hashtag2, h1.created_at AS time1, h2.created_at AS time2
FROM social_media.hashtags h1
JOIN social_media.hashtags h2
  ON DATE(h1.created_at) = DATE(h2.created_at)
WHERE h1.hashtag_id < h2.hashtag_id
  AND ABS(EXTRACT(EPOCH FROM (h1.created_at - h2.created_at))) < 7200
  AND SUBSTRING(h1.tag_name,1,1) = SUBSTRING(h2.tag_name,1,1)
ORDER BY LEAST(h1.created_at, h2.created_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 hospitality_technology.properties (
    property_id character varying(64) NOT NULL,  -- unique identifier for the property (hotel, resort, etc.)
    property_name character varying(255) NOT NULL, -- name of the property
    address_line1 character varying(255) NOT NULL, -- primary address line
    address_line2 character varying(255), -- secondary address line
    city character varying(100) NOT NULL, -- city
    state_province character varying(100), -- state or province
    postal_code character varying(20) NOT NULL, -- zip or postal code
    country_code character varying(3) NOT NULL, -- ISO country code (e.g., USA, CAN)
    phone_number character varying(30), -- main contact phone
    email_address character varying(255), -- main contact email
    property_type character varying(50) NOT NULL, -- e.g., Hotel, Resort, B&B, Motel
    star_rating numeric(2,1), -- star rating (e.g., 4.5)
    timezone character varying(64) NOT NULL, -- IANA timezone ID (e.g., America/New_York)
    manager_staff_id character varying(64), -- FK to staff table for the general manager
    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record creation time
    updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record last update time
    PRIMARY KEY (property_id)
)
CREATE TABLE hospitality_technology.rooms ( room_id text, property_id text, room_number text, room_type_id text, floor integer, status text, is_smoking boolean, features text, current_condition text, last_cleaned_at timestamp )
CREATE TABLE hospitality_technology.guests ( guest_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, email character varying(255) UNIQUE, phone_number character varying(30), date_of_birth date, address_line1 character varying(255), city character varying(100), state_province character varying(100), postal_code character varying(20), country_code character varying(3), preferences text, loyalty_member_id character varying(64) UNIQUE, communication_consent boolean DEFAULT true, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (guest_id) )
CREATE TABLE hospitality_technology.reservations ( reservation_id text PRIMARY KEY, property_id text, guest_id text, room_id text, room_type_id text, check_in_date date, check_out_date date, actual_check_in_ts timestamp, actual_check_out_ts timestamp, num_adults int, num_children int, status text, booking_source text, rate_plan_id text, total_amount numeric, amount_paid numeric, special_requests text, created_at timestamp, updated_at timestamp )
CREATE TABLE hospitality_technology.services ( service_id text PRIMARY KEY, property_id text, service_name text, description text, category text, price numeric, unit text, is_available boolean, department text )
CREATE TABLE hospitality_technology.payments ( payment_id character varying(64) NOT NULL, reservation_id character varying(64), guest_id character varying(64) NOT NULL, bill_id character varying(64), amount numeric(12,2) NOT NULL, currency_code character varying(3) NOT NULL, payment_method character varying(50) NOT NULL, card_type character varying(50), card_last_four character varying(4), transaction_ref character varying(128), payment_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, status character varying(50) NOT NULL, staff_id_processed character varying(64), notes text, PRIMARY KEY (payment_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (staff_id_processed) REFERENCES hospitality_technology.staff(staff_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] Show me properties that are listed as type 'Hotel' and are located in 'Canada'. List the property name, city, and postal code.

[Assistant] SELECT property_name, city, postal_code FROM hospitality_technology.properties WHERE property_type = 'Hotel' AND country_code = 'CAN';

[User] Refine this list to only include properties with a star rating of 4 or higher, and sort the results by star rating descending.

[Assistant] SELECT property_name, city, postal_code FROM hospitality_technology.properties WHERE property_type = 'Hotel' AND country_code = 'CAN' AND star_rating >= 4 ORDER BY star_rating 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.assets ( asset_id character varying(64) NOT NULL, name character varying(128) NOT NULL, symbol character varying(32) NOT NULL, type character varying(32) NOT NULL, PRIMARY KEY (asset_id) )
CREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )

[User] List all UTXO IDs, addresses, and amounts for unspent UTXOs with an amount between 200 and 800.

[Assistant] SELECT utxo_id, address, amount FROM trading_platform.utxos WHERE spent = false AND amount BETWEEN 200 AND 800;


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.trades ( trade_id text, account_id text, security_id text, order_id text, trade_type text, quantity numeric, price_per_unit numeric, total_amount numeric, commission numeric, trade_timestamp timestamp, settlement_date date, status text, execution_venue text )

[User] For each customer, show their full name, email, and the total trade amount they have made, joining customers to trades via account_id.

[Assistant]
SELECT c.customer_id, c.first_name, c.last_name, c.email, SUM(t.total_amount) AS total_trade_amount
FROM financial_services.customers c
JOIN financial_services.trades t ON c.customer_id = t.account_id
GROUP BY c.customer_id, c.first_name, c.last_name, c.email;

[User] Actually, can you only include trades where the total_amount is over 1000?

[Assistant]
SELECT c.customer_id, c.first_name, c.last_name, c.email, SUM(t.total_amount) AS total_trade_amount
FROM financial_services.customers c
JOIN financial_services.trades t ON c.customer_id = t.account_id
WHERE t.total_amount > 1000
GROUP BY c.customer_id, c.first_name, c.last_name, c.email;

[User] Now, filter to only include customers whose trade count is at least 3.

[Assistant]
SELECT c.customer_id, c.first_name, c.last_name, c.email, SUM(t.total_amount) AS total_trade_amount, COUNT(t.trade_id) AS trade_count
FROM financial_services.customers c
JOIN financial_services.trades t ON c.customer_id = t.account_id
WHERE t.total_amount > 1000
GROUP BY c.customer_id, c.first_name, c.last_name, c.email
HAVING COUNT(t.trade_id) >= 3;

[User] Please sort the result by total_trade_amount in descending order.

[Assistant]
SELECT c.customer_id, c.first_name, c.last_name, c.email, SUM(t.total_amount) AS total_trade_amount, COUNT(t.trade_id) AS trade_count
FROM financial_services.customers c
JOIN financial_services.trades t ON c.customer_id = t.account_id
WHERE t.total_amount > 1000
GROUP BY c.customer_id, c.first_name, c.last_name, c.email
HAVING COUNT(t.trade_id) >= 3
ORDER BY total_trade_amount DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE hospitality_technology.services ( service_id text PRIMARY KEY, property_id text, service_name text, description text, category text, price numeric, unit text, is_available boolean, department text )

[User] Which available services in the 'Wellness' category are offered by each property? Please show property_id, service_name, and price.

[Assistant] SELECT property_id, service_name, price FROM hospitality_technology.services WHERE category = 'Wellness' AND is_available = TRUE;

[User] Instead, show only those services with a price greater than 80 and include the department in the result.

[Assistant] SELECT property_id, service_name, price, department FROM hospitality_technology.services WHERE category = 'Wellness' AND is_available = TRUE AND price > 80;


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

[User] For Sui coins, can you show the coin_type and owner address for each coin where the balance is greater than 100000?

[Assistant] SELECT coin_type, owner FROM sui_coins WHERE CAST(balance AS NUMERIC) > 100000;

[User] Can you also show the symbol and name for each coin by joining with sui_coins_metadata?

[Assistant] SELECT sc.coin_type, scm.symbol, scm.name, sc.owner FROM sui_coins sc JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type WHERE CAST(sc.balance AS NUMERIC) > 100000;

[User] Limit the results to only coins where the metadata status is 'exists' and sort the output by owner address ascending.

[Assistant] SELECT sc.coin_type, scm.symbol, scm.name, sc.owner FROM sui_coins sc JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type WHERE CAST(sc.balance AS NUMERIC) > 100000 AND scm.status = 'exists' ORDER BY sc.owner ASC;

[User] Actually, only show coins owned by addresses starting with '0xabc' and display the first 5 results only.

[Assistant] SELECT sc.coin_type, scm.symbol, scm.name, sc.owner FROM sui_coins sc JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type WHERE CAST(sc.balance AS NUMERIC) > 100000 AND scm.status = 'exists' AND sc.owner LIKE '0xabc%' ORDER BY sc.owner ASC 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 legal_services.clients ( client_id text, first_name text, last_name text, company_name text, email text, phone text, address text, date_registered timestamp, status text )
CREATE TABLE legal_services.law_firms ( firm_id text, firm_name text, address text, phone text, website text, founded_date date, managing_partner_id text )
CREATE TABLE legal_services.cases ( case_id text, case_number text, case_name text, client_id text, lead_lawyer_id text, case_type text, status text, date_opened timestamp, date_closed timestamp, description text, court_jurisdiction text )
CREATE TABLE legal_services.time_entries ( entry_id text, case_id text, lawyer_id text, date_worked date, hours_spent numeric, billing_rate numeric, description text, is_billable boolean, is_billed boolean, invoice_id text, created_at timestamp )

[User] List all open cases with case_number, case_name, and the client's email and phone.

[Assistant]
SELECT c.case_number,
       c.case_name,
       cl.email,
       cl.phone
FROM legal_services.cases c
JOIN legal_services.clients cl ON c.client_id = cl.client_id
WHERE c.status = 'Open';

[User] Also include the law_firm name based on the client's company_name, and only include cases opened in the last 6 months.

[Assistant]
SELECT c.case_number,
       c.case_name,
       cl.email,
       cl.phone,
       lf.firm_name
FROM legal_services.cases c
JOIN legal_services.clients cl ON c.client_id = cl.client_id
LEFT JOIN legal_services.law_firms lf ON cl.company_name = lf.firm_name
WHERE c.status = 'Open'
  AND c.date_opened >= CURRENT_DATE - INTERVAL '6 months';


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, project_id character varying(32) NOT NULL, project_name character varying(128) NOT NULL, rounds_name character varying(32), investment_value numeric(38,14), investment_date character varying(128), introduction character varying(128), valuation numeric(38,14) )
CREATE TABLE narrative_info ( narrative character varying(512) NOT NULL, top_3_coins text, price_change_percentage_1h double precision, price_change_percentage_24h double precision, price_change_percentage_7d double precision, market_cap double precision, volume_24h double precision, trend_rank bigint, token_num bigint )
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) )
CREATE TABLE smart_money_token_inflow ( token_address character varying(100) NOT NULL, token_symbol character varying(100), token_amount numeric(38,2), usd_value numeric(38,2), avg_price numeric(38,6), type int, address_amount integer, narrative character varying(100), chain character varying(100) )

[User] How many tokens had a net positive flow according to smart_money_token_performance, and what is their average ROI?

[Assistant]
SELECT COUNT(*) AS token_count, AVG(roi) AS avg_roi
FROM smart_money_token_performance
WHERE net_flow > 0;

[User] Now, break this down by chain, and order the results by avg_roi descending.

[Assistant]
SELECT chain, COUNT(*) AS token_count, AVG(roi) AS avg_roi
FROM smart_money_token_performance
WHERE net_flow > 0
GROUP BY chain
ORDER BY avg_roi 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.comments ( comment_id text PRIMARY KEY, post_id text, user_id text, parent_comment_id text, content text, created_at timestamp, updated_at timestamp )
CREATE TABLE social_media.post_hashtags ( post_hashtag_id character varying(64) NOT NULL, post_id character varying(64) NOT NULL, hashtag_id character varying(64) NOT NULL, PRIMARY KEY (post_hashtag_id), CONSTRAINT unique_post_hashtag UNIQUE (post_id, hashtag_id) )
CREATE TABLE social_media.messages ( message_id text, conversation_id text, sender_user_id text, content text, media_url text, media_type text, sent_at timestamp, read_at timestamp )
CREATE TABLE social_media.conversations ( conversation_id.text, created_at.timestamp, last_message_at.timestamp, is_group_chat.boolean, group_name.text )
CREATE TABLE social_media.notifications ( notification_id text PRIMARY KEY, recipient_user_id text, sender_user_id text, notification_type text, target_entity_id text, target_entity_type text, created_at timestamp, read_at timestamp )

[User] I want a list of group conversations with at least one unread message, including the conversation_id, group_name, and the count of unread messages, joining messages and conversations tables.

[Assistant]
SELECT c.conversation_id, c.group_name, COUNT(m.message_id) AS unread_count
FROM social_media.conversations c
JOIN social_media.messages m ON c.conversation_id = m.conversation_id
WHERE c.is_group_chat = TRUE
  AND m.read_at IS NULL
GROUP BY c.conversation_id, c.group_name;

[User] Actually, only include group chats where the last_message_at is within the last 7 days.

[Assistant]
SELECT c.conversation_id, c.group_name, COUNT(m.message_id) AS unread_count
FROM social_media.conversations c
JOIN social_media.messages m ON c.conversation_id = m.conversation_id
WHERE c.is_group_chat = TRUE
  AND m.read_at IS NULL
  AND c.last_message_at >= NOW() - INTERVAL '7 days'
GROUP BY c.conversation_id, c.group_name;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE government_services.citizens (
    citizen_id character varying(64) NOT NULL,  -- unique identifier for the citizen
    national_id_number character varying(128) NOT NULL UNIQUE, -- official national identification number
    first_name character varying(100) NOT NULL,
    last_name character varying(100) NOT NULL,
    date_of_birth date NOT NULL,
    gender character varying(20),
    primary_address text NOT NULL, -- full primary residential address
    contact_email character varying(128) UNIQUE,
    contact_phone character varying(32),
    registration_date timestamp NOT NULL, -- when the citizen profile was created
    is_verified boolean DEFAULT false, -- whether identity has been officially verified
    PRIMARY KEY (citizen_id)
)

[User] List each citizen's first and last name along with the first and last name of another citizen who shares the same last name. Show each pair only once.

[Assistant]
SELECT c1.first_name || ' ' || c1.last_name AS citizen_name,
       c2.first_name || ' ' || c2.last_name AS other_citizen_name
FROM government_services.citizens c1
JOIN government_services.citizens c2
  ON c1.last_name = c2.last_name
 AND c1.citizen_id < c2.citizen_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 healthcare.appointments ( appointment_id text PRIMARY KEY, patient_id text, doctor_id text, appointment_time timestamp, duration_minutes int, reason text, status text, location_id text, notes text, created_at timestamp )

[User] I need to identify overlapping appointments for each doctor. Return doctor_id, the first appointment_id, the overlapping appointment_id, and the overlap start time.

[Assistant]
SELECT A.doctor_id,
       A.appointment_id AS a1,
       B.appointment_id AS a2,
       GREATEST(A.appointment_time, B.appointment_time) AS overlap_start
FROM healthcare.appointments A
JOIN healthcare.appointments B
  ON A.doctor_id = B.doctor_id
 AND A.appointment_id < B.appointment_id
 AND A.appointment_time < B.appointment_time + B.duration_minutes * INTERVAL '1 minute'
 AND B.appointment_time < A.appointment_time + A.duration_minutes * INTERVAL '1 minute';

[User] Actually, I only care about overlaps that last more than 15 minutes.

[Assistant]
SELECT A.doctor_id,
       A.appointment_id AS a1,
       B.appointment_id AS a2,
       GREATEST(A.appointment_time, B.appointment_time) AS overlap_start
FROM healthcare.appointments A
JOIN healthcare.appointments B
  ON A.doctor_id = B.doctor_id
 AND A.appointment_id < B.appointment_id
 AND A.appointment_time < B.appointment_time + B.duration_minutes * INTERVAL '1 minute'
 AND B.appointment_time < A.appointment_time + A.duration_minutes * INTERVAL '1 minute'
 AND (LEAST(A.appointment_time + A.duration_minutes * INTERVAL '1 minute',
            B.appointment_time + B.duration_minutes * INTERVAL '1 minute')
      - GREATEST(A.appointment_time, B.appointment_time)) > INTERVAL '15 minutes';

[User] Also, exclude any appointments that have a status of 'Cancelled'.

[Assistant]
SELECT A.doctor_id,
       A.appointment_id AS a1,
       B.appointment_id AS a2,
       GREATEST(A.appointment_time, B.appointment_time) AS overlap_start
FROM healthcare.appointments A
JOIN healthcare.appointments B
  ON A.doctor_id = B.doctor_id
 AND A.appointment_id < B.appointment_id
 AND A.appointment_time < B.appointment_time + B.duration_minutes * INTERVAL '1 minute'
 AND B.appointment_time < A.appointment_time + A.duration_minutes * INTERVAL '1 minute'
 AND (LEAST(A.appointment_time + A.duration_minutes * INTERVAL '1 minute',
            B.appointment_time + B.duration_minutes * INTERVAL '1 minute')
      - GREATEST(A.appointment_time, B.appointment_time)) > INTERVAL '15 minutes'
WHERE A.status <> 'Cancelled'
  AND B.status <> 'Cancelled';


[User] For all chains, which token held by centralized exchanges (CEX) has the highest ROI according to smart money token performance? Show token symbol, chain, exchange, total USD value held on CEX, and the smart money ROI.

[Assistant]
SELECT c.token_symbol, c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, s.roi
FROM cex_token_balance c
JOIN smart_money_token_performance s ON c.token_symbol = s.token_symbol AND c.chain = s.chain
GROUP BY c.token_symbol, c.chain, c.exchange, s.roi
ORDER BY s.roi DESC
LIMIT 1;

[User] Instead of just the top one, show the top 3 tokens by ROI, and only include cases where the total USD value held on CEX is greater than $2,000,000.

[Assistant]
SELECT c.token_symbol, c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, s.roi
FROM cex_token_balance c
JOIN smart_money_token_performance s ON c.token_symbol = s.token_symbol AND c.chain = s.chain
GROUP BY c.token_symbol, c.chain, c.exchange, s.roi
HAVING SUM(c.usd_value) > 2000000
ORDER BY s.roi DESC
LIMIT 3;

[User] Add the last recorded price for each token, and sort by total_usd_value in descending order.

[Assistant]
SELECT c.token_symbol, c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, s.roi, MAX(c.price) AS last_price
FROM cex_token_balance c
JOIN smart_money_token_performance s ON c.token_symbol = s.token_symbol AND c.chain = s.chain
GROUP BY c.token_symbol, c.chain, c.exchange, s.roi
HAVING SUM(c.usd_value) > 2000000
ORDER BY total_usd_value DESC
LIMIT 3;

[User] I got duplicate tokens across exchanges. Can you show only the top exchange (with the greatest USD value) per token and chain combination?

[Assistant]
WITH cex_totals AS (
  SELECT c.token_symbol, c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, s.roi, MAX(c.price) AS last_price,
         ROW_NUMBER() OVER (PARTITION BY c.token_symbol, c.chain ORDER BY SUM(c.usd_value) DESC) as rn
  FROM cex_token_balance c
  JOIN smart_money_token_performance s ON c.token_symbol = s.token_symbol AND c.chain = s.chain
  GROUP BY c.token_symbol, c.chain, c.exchange, s.roi
  HAVING SUM(c.usd_value) > 2000000
)
SELECT token_symbol, chain, exchange, total_usd_value, roi, last_price
FROM cex_totals
WHERE rn = 1
ORDER BY total_usd_value DESC
LIMIT 3;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.clients ( client_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, company_name character varying(200), email character varying(128) UNIQUE NOT NULL, phone character varying(32), address text, date_registered timestamp NOT NULL, status character varying(32) NOT NULL, PRIMARY KEY (client_id) )
CREATE TABLE legal_services.lawyers ( lawyer_id text PRIMARY KEY, first_name text, last_name text, bar_number text UNIQUE, firm_id text, email text UNIQUE, phone text, specialization text, hire_date timestamp, is_partner bool )
CREATE TABLE legal_services.law_firms ( firm_id text, firm_name text, address text, phone text, website text, founded_date date, managing_partner_id text )
CREATE TABLE legal_services.cases ( case_id character varying(64) NOT NULL, case_number character varying(100) UNIQUE, case_name text NOT NULL, client_id character varying(64) NOT NULL, lead_lawyer_id character varying(64) NOT NULL, case_type character varying(100) NOT NULL, status character varying(50) NOT NULL, date_opened timestamp NOT NULL, date_closed timestamp, description text, court_jurisdiction character varying(128), PRIMARY KEY (case_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 text PRIMARY KEY, invoice_number text UNIQUE, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )
CREATE TABLE legal_services.appointments ( appointment_id text PRIMARY KEY, client_id text, lawyer_id text, case_id text, start_time timestamp, end_time timestamp, location text, subject text, notes text, status text, created_at timestamp )

[User] Show all cases with at least one billed and billable time entry, including case number, case name, total billed amount, and billed hours.

[Assistant]
SELECT cs.case_number, cs.case_name, SUM(te.hours_spent * te.billing_rate) AS total_billed_amount, SUM(te.hours_spent) AS total_billed_hours
FROM legal_services.cases cs
JOIN legal_services.time_entries te ON cs.case_id = te.case_id
WHERE te.is_billable = TRUE AND te.is_billed = TRUE
GROUP BY cs.case_number, cs.case_name;

[User] Add the lead lawyer's full name to the result.

[Assistant]
SELECT cs.case_number, cs.case_name, l.first_name || ' ' || l.last_name AS lead_lawyer_full_name, SUM(te.hours_spent * te.billing_rate) AS total_billed_amount, SUM(te.hours_spent) AS total_billed_hours
FROM legal_services.cases cs
JOIN legal_services.time_entries te ON cs.case_id = te.case_id
JOIN legal_services.lawyers l ON cs.lead_lawyer_id = l.lawyer_id
WHERE te.is_billable = TRUE AND te.is_billed = TRUE
GROUP BY cs.case_number, cs.case_name, l.first_name, l.last_name;

[User] Filter for cases where the total billed amount exceeds 8000, and only include those opened after January 1, 2023.

[Assistant]
SELECT cs.case_number, cs.case_name, l.first_name || ' ' || l.last_name AS lead_lawyer_full_name, SUM(te.hours_spent * te.billing_rate) AS total_billed_amount, SUM(te.hours_spent) AS total_billed_hours
FROM legal_services.cases cs
JOIN legal_services.time_entries te ON cs.case_id = te.case_id
JOIN legal_services.lawyers l ON cs.lead_lawyer_id = l.lawyer_id
WHERE te.is_billable = TRUE AND te.is_billed = TRUE AND cs.date_opened > '2023-01-01'
GROUP BY cs.case_number, cs.case_name, l.first_name, l.last_name
HAVING SUM(te.hours_spent * te.billing_rate) > 8000;

[User] Add the invoice numbers linked to these cases in the output.

[Assistant]
SELECT cs.case_number, cs.case_name, l.first_name || ' ' || l.last_name AS lead_lawyer_full_name, SUM(te.hours_spent * te.billing_rate) AS total_billed_amount, SUM(te.hours_spent) AS total_billed_hours, STRING_AGG(DISTINCT inv.invoice_number, ', ') AS invoice_numbers
FROM legal_services.cases cs
JOIN legal_services.time_entries te ON cs.case_id = te.case_id
JOIN legal_services.lawyers l ON cs.lead_lawyer_id = l.lawyer_id
LEFT JOIN legal_services.invoices inv ON cs.case_id = inv.case_id
WHERE te.is_billable = TRUE AND te.is_billed = TRUE AND cs.date_opened > '2023-01-01'
GROUP BY cs.case_number, cs.case_name, l.first_name, l.last_name
HAVING SUM(te.hours_spent * te.billing_rate) > 8000;


System:
You are an expert in writing database language and you can refuse the user's question if the question is not related to the table structure. 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 train_station_management.stations (
    station_id character varying(64) NOT NULL,  -- Unique identifier for the station
    station_name character varying(128) NOT NULL, -- Name of the station
    city character varying(100) NOT NULL, -- City where the station is located
    state_province character varying(100), -- State or province
    country_code character varying(3) NOT NULL, -- ISO country code
    address text, -- Full address of the station
    timezone character varying(64) NOT NULL, -- Timezone ID (e.g., 'America/New_York')
    number_of_platforms integer NOT NULL DEFAULT 0, -- Total number of platforms
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- When the station record was created
    last_updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- When the station record was last updated
    PRIMARY KEY (station_id)
)

[User] What is the current number of passengers at station with ID 'ST123' right now?

[Assistant] I'm sorry, but I can't provide information on the current number of passengers at a station. The data I have access to only includes static details about stations such as their name, location, and number of platforms, not real-time passenger counts.


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 text, property_id text, guest_id text, room_id text, room_type_id text, check_in_date date, check_out_date date, actual_check_in_ts timestamp, actual_check_out_ts timestamp, num_adults integer, num_children integer, status text, booking_source text, rate_plan_id text, total_amount numeric, amount_paid numeric, special_requests text, created_at timestamp, updated_at timestamp )

[User] Provide the monthly reservation count and total revenue for reservations made through 'Online Travel Agency' in 2023.

[Assistant]
SELECT DATE_TRUNC('month', check_in_date) AS month,
       COUNT(*) AS reservation_count,
       SUM(total_amount) AS total_revenue
FROM hospitality_technology.reservations
WHERE booking_source = 'Online Travel Agency'
  AND check_in_date BETWEEN '2023-01-01' AND '2023-12-31'
GROUP BY DATE_TRUNC('month', check_in_date)
ORDER BY month;

[User] Now show only those months where total_revenue exceeds 50000 and sort by total_revenue descending.

[Assistant]
SELECT month,
       reservation_count,
       total_revenue
FROM (
  SELECT DATE_TRUNC('month', check_in_date) AS month,
         COUNT(*) AS reservation_count,
         SUM(total_amount) AS total_revenue
  FROM hospitality_technology.reservations
  WHERE booking_source = 'Online Travel Agency'
    AND check_in_date BETWEEN '2023-01-01' AND '2023-12-31'
  GROUP BY DATE_TRUNC('month', check_in_date)
) t
WHERE total_revenue > 50000
ORDER BY total_revenue 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 NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the player
    username character varying(100) NOT NULL UNIQUE, -- player's chosen display name
    email character varying(255) NOT NULL UNIQUE, -- player's email address for login/recovery
    password_hash text NOT NULL, -- securely hashed password
    registration_date timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the player account was created
    last_login timestamp with time zone, -- timestamp of the last successful login
    country_code character(2), -- player's country (ISO 3166-1 alpha-2)
    status character varying(20) NOT NULL DEFAULT 'active', -- account status (e.g., active, banned, suspended)
    profile_data jsonb, -- flexible field for avatar url, bio, preferences etc.
    PRIMARY KEY (player_id)
)
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 NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game session
    player_id uuid NOT NULL, -- FK linking to the players table
    game_id uuid NOT NULL, -- FK linking to the games table
    server_id uuid, -- FK linking to the servers table (nullable for single-player)
    start_time timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the session began
    end_time timestamp with time zone, -- when the session ended (null if ongoing)
    duration_seconds integer, -- calculated duration of the session in seconds
    score integer, -- player's score for the session, if applicable
    session_data jsonb, -- flexible field for session-specific info (e.g., map played, character used)
    PRIMARY KEY (session_id)
    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),
    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id),
    -- FOREIGN KEY (server_id) REFERENCES gaming_technology.servers(server_id)
)
CREATE TABLE gaming_technology.servers (
    server_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game server instance
    game_id uuid NOT NULL, -- FK linking to the game this server hosts
    server_name character varying(150), -- display name for the server
    region character varying(50) NOT NULL, -- geographical region (e.g., us-east-1, eu-west-2)
    ip_address character varying(45), -- IP address (IPv4 or IPv6)
    port integer, -- network port number
    current_players integer NOT NULL DEFAULT 0, -- number of players currently connected
    max_players integer NOT NULL, -- maximum player capacity
    status character varying(30) NOT NULL DEFAULT 'offline', -- server status (e.g., online, offline, maintenance)
    last_heartbeat timestamp with time zone, -- last time the server reported its status
    PRIMARY KEY (server_id)
    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)
)
CREATE TABLE gaming_technology.achievements (
    achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an achievement definition
    game_id uuid NOT NULL, -- FK linking to the game the achievement belongs to
    name character varying(150) NOT NULL, -- name of the achievement
    description text NOT NULL, -- how to unlock the achievement
    icon_url character varying(255), -- URL for the achievement's icon
    points integer DEFAULT 0, -- points awarded for unlocking (optional)
    hidden boolean DEFAULT false, -- whether the achievement details are hidden until unlocked
    PRIMARY KEY (achievement_id)
    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)
)
CREATE TABLE gaming_technology.player_achievements (
    player_achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for this unlock instance
    player_id uuid NOT NULL, -- FK linking to the player who unlocked it
    achievement_id uuid NOT NULL, -- FK linking to the achievement definition
    unlocked_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the achievement was unlocked
    PRIMARY KEY (player_achievement_id),
    UNIQUE (player_id, achievement_id) -- Ensure a player can only unlock an achievement once
    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),
    -- FOREIGN KEY (achievement_id) REFERENCES gaming_technology.achievements(achievement_id)
)

[User] Could you provide the total number of game sessions and the number of distinct players for each game genre? Display the genre, session count, and player count.

[Assistant] SELECT g.genre, COUNT(gs.session_id) AS session_count, COUNT(DISTINCT gs.player_id) AS player_count FROM gaming_technology.game_sessions AS gs JOIN gaming_technology.games AS g ON gs.game_id = g.game_id WHERE g.genre IS NOT NULL GROUP BY g.genre ORDER BY g.genre;

[User] Thanks. Can you modify the query to only include games that were released after the year 2020?

[Assistant] SELECT g.genre, COUNT(gs.session_id) AS session_count, COUNT(DISTINCT gs.player_id) AS player_count FROM gaming_technology.game_sessions AS gs JOIN gaming_technology.games AS g ON gs.game_id = g.game_id WHERE g.genre IS NOT NULL AND g.release_date >= '2021-01-01' GROUP BY g.genre ORDER BY g.genre;


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 PRIMARY KEY, title text, developer_id uuid, publisher_id uuid, genre text, release_date date, description text, platform text, engine text, website text )
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, game_id.uuid, server_name.text, region.text, ip_address.text, port.integer, current_players.integer, max_players.integer, status.text, last_heartbeat.timestamptz )
CREATE TABLE gaming_technology.achievements ( achievement_id.uuid, game_id.uuid, name.text, description.text, icon_url.text, points.integer, hidden.boolean )
CREATE TABLE gaming_technology.player_achievements ( player_achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), player_id uuid NOT NULL, achievement_id uuid NOT NULL, unlocked_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (player_achievement_id), UNIQUE (player_id, achievement_id) )
CREATE TABLE gaming_technology.in_game_items ( item_id uuid, game_id uuid, item_name text, item_type text, description text, rarity text, cost_currency text, cost_amount numeric, attributes jsonb )
CREATE TABLE gaming_technology.player_inventory ( inventory_id.uuid, player_id.uuid, item_id.uuid, quantity.integer, acquired_at.timestamptz, instance_data.jsonb )

[User] List games that have servers deployed in more than one geographical region. Show the game title and the count of regions.

[Assistant] SELECT g.title, count(DISTINCT s.region) AS region_count FROM games AS g JOIN servers AS s ON g.game_id = s.game_id GROUP BY g.game_id, g.title HAVING count(DISTINCT s.region) > 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 social_media.users ( user_id text, username text, email text, password_hash text, full_name text, profile_picture_url text, bio text, location text, created_at timestamp, updated_at timestamp, is_verified boolean )
CREATE TABLE social_media.posts ( post_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, content text, media_url text, media_type character varying(20), created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, visibility character varying(20) NOT NULL DEFAULT 'public', location_lat numeric(9,6), location_lon numeric(9,6), PRIMARY KEY (post_id) )
CREATE TABLE social_media.post_hashtags (
    post_hashtag_id character varying(64) NOT NULL, -- unique identifier for the post-hashtag link
    post_id character varying(64) NOT NULL, -- identifier of the post (FK to posts.post_id)
    hashtag_id character varying(64) NOT NULL, -- identifier of the hashtag (FK to hashtags.hashtag_id)
    PRIMARY KEY (post_hashtag_id),
    CONSTRAINT unique_post_hashtag UNIQUE (post_id, hashtag_id) -- prevent duplicate tags on a post
)
CREATE TABLE social_media.messages ( message_id text PRIMARY KEY, conversation_id text, sender_user_id text, content text, media_url text, media_type text, sent_at timestamp, read_at timestamp )
CREATE TABLE social_media.conversation_participants ( participant_id text PRIMARY KEY, conversation_id text, user_id text, joined_at timestamp, last_read_at timestamp )
CREATE TABLE social_media.notifications ( notification_id.text, recipient_user_id.text, sender_user_id.text, notification_type.text, target_entity_id.text, target_entity_type.text, created_at.timestamp, read_at.timestamp )
CREATE TABLE social_media.user_settings ( setting_id text, user_id text, theme text, email_notifications_enabled boolean, push_notifications_enabled boolean, private_profile boolean, updated_at timestamp )

[User] Show me all users and the posts they have created, including the user's username and the post content.

[Assistant]
SELECT u.username, p.post_id, p.content
FROM social_media.users u
JOIN social_media.posts p ON u.user_id = p.user_id;

[User] Actually, can you please also include the post creation time and only show posts that have a media attachment?

[Assistant]
SELECT u.username, p.post_id, p.content, p.created_at
FROM social_media.users u
JOIN social_media.posts p ON u.user_id = p.user_id
WHERE p.media_url IS NOT NULL AND p.media_url <> '';