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 web3.contracts ( contract_id text, address text, abi text, bytecode text, deployer_address text, deployed_at timestamp, network_id text, status text )
CREATE TABLE web3.transactions ( transaction_id text, from_address text, to_address text, value numeric, gas_used integer, gas_price numeric, block_number integer, timestamp timestamp, input_data text, status text, nonce integer )
CREATE TABLE web3.tokens ( token_id text, contract_address text, token_name text, token_symbol text, decimals integer, total_supply numeric )
CREATE TABLE web3.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )
CREATE TABLE web3.users ( user_id text, username text, email text, password_hash text, created_at timestamp )

[User] Show all tokens along with the username of the deployer of the contract where each token was created. Include the token symbol, token name, contract address, and username.

[Assistant]
SELECT t.token_symbol, t.token_name, t.contract_address, u.username
FROM web3.tokens t
JOIN web3.contracts c ON t.contract_address = c.address
LEFT JOIN web3.wallets w ON c.deployer_address = w.address
LEFT JOIN web3.users u ON w.user_id = u.user_id;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE token_metas ( block_timestamp timestamp, block_number bigint, transaction_hash varchar, transaction_index bigint, from_address varchar, contract_address varchar, symbol varchar, total_supply varchar, name varchar, decimals bigint, is_erc20 integer, is_erc721 integer, is_erc1155 integer, is_proxy integer, extra_info varchar, pk integer )
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_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_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 ( uuid varchar, blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )
CREATE TABLE token_prices_latest ( blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )
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_activities_avalanche ( 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] I would like to calculate the average rarity_score for each NFT collection on the Ethereum blockchain.

[Assistant]
SELECT c.contract_address,
       AVG(m.rarity_score) AS avg_rarity
FROM nft_collections c
JOIN nft_metadata m
  ON c.contract_address = m.contract_address
WHERE c.blockchain = 'Ethereum'
GROUP BY c.contract_address;

[User] Please include the collection name and floor_price in the output.

[Assistant]
SELECT c.contract_address,
       c.name AS collection_name,
       AVG(m.rarity_score) AS avg_rarity,
       c.floor_price
FROM nft_collections c
JOIN nft_metadata m
  ON c.contract_address = m.contract_address
WHERE c.blockchain = 'Ethereum'
GROUP BY c.contract_address, c.name, c.floor_price;

[User] Filter to only include collections with token_count > 1000 and sort by floor_price descending.

[Assistant]
SELECT c.contract_address,
       c.name AS collection_name,
       AVG(m.rarity_score) AS avg_rarity,
       c.floor_price
FROM nft_collections c
JOIN nft_metadata m
  ON c.contract_address = m.contract_address
WHERE c.blockchain = 'Ethereum'
  AND c.token_count > 1000
GROUP BY c.contract_address, c.name, c.floor_price
ORDER BY c.floor_price::numeric DESC;

[User] Limit the results to the top 5 collections.

[Assistant]
SELECT c.contract_address,
       c.name AS collection_name,
       AVG(m.rarity_score) AS avg_rarity,
       c.floor_price
FROM nft_collections c
JOIN nft_metadata m
  ON c.contract_address = m.contract_address
WHERE c.blockchain = 'Ethereum'
  AND c.token_count > 1000
GROUP BY c.contract_address, c.name, c.floor_price
ORDER BY c.floor_price::numeric DESC
LIMIT 5;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE government_services.agencies ( agency_id text PRIMARY KEY, 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.applications ( application_id text PRIMARY KEY, citizen_id text, service_id text, submitted_at timestamp, status text, last_updated_at timestamp, assigned_employee_id text, decision_date date, notes text, reference_number text )
CREATE TABLE government_services.documents ( document_id text PRIMARY KEY, application_id text, citizen_id text, document_type text, file_reference text, upload_timestamp timestamp, expiry_date date, verification_status text, verified_by_employee_id text, verification_timestamp timestamp )
CREATE TABLE government_services.payments ( payment_id text PRIMARY KEY, 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 PRIMARY KEY, 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.service_locations ( location_id text PRIMARY KEY, agency_id text, location_name text, address text, city text, state text, postal_code text, latitude numeric, longitude numeric, operating_hours text, contact_phone text, is_accessible boolean )
CREATE TABLE government_services.appointments ( appointment_id text PRIMARY KEY, citizen_id text, employee_id text, location_id text, service_id text, scheduled_start_time timestamp, scheduled_end_time timestamp, purpose text, status text, booking_method text, created_at timestamp, notes text )

[User] For each employee, retrieve their full name and the number of appointments scheduled for them in the next 7 days, including employees with no appointments.

[Assistant]
SELECT e.first_name || ' ' || e.last_name AS full_name,
       COUNT(a.appointment_id) AS appointment_count
FROM government_services.employees e
LEFT JOIN government_services.appointments a
  ON e.employee_id = a.employee_id
  AND a.scheduled_start_time BETWEEN now() AND now() + INTERVAL '7 days'
GROUP BY e.first_name, e.last_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 web3.events ( event_id text PRIMARY KEY, contract_id text, event_name text, data text, emitted_at timestamp, transaction_id text, log_index int )
CREATE TABLE web3.token_transfers ( transfer_id text PRIMARY KEY, token_id text, from_address text, to_address text, value numeric, transaction_id text, log_index int )

[User] List all token transfers with values greater than 1000, including the token ID and transaction ID.

[Assistant] SELECT transfer_id, token_id, transaction_id, value FROM web3.token_transfers WHERE value > 1000;

[User] Actually, I also need to see the event names associated with these transactions.

[Assistant] SELECT tt.transfer_id, tt.token_id, tt.transaction_id, tt.value, e.event_name FROM web3.token_transfers tt LEFT JOIN web3.events e ON tt.transaction_id = e.transaction_id WHERE tt.value > 1000;

[User] There's a typo in your SQL, it should be 'token_transfers' not 'token_transfers'. Also, sort the results by value in descending order.

[Assistant] SELECT tt.transfer_id, tt.token_id, tt.transaction_id, tt.value, e.event_name FROM web3.token_transfers tt LEFT JOIN web3.events e ON tt.transaction_id = e.transaction_id WHERE tt.value > 1000 ORDER BY tt.value DESC;

[User] Now filter to only show transfers that have at least one associated event.

[Assistant] SELECT tt.transfer_id, tt.token_id, tt.transaction_id, tt.value, e.event_name FROM web3.token_transfers tt JOIN web3.events e ON tt.transaction_id = e.transaction_id WHERE tt.value > 1000 ORDER BY tt.value DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE insurance.claims ( claim_id text PRIMARY KEY, policy_id text, customer_id text, incident_date timestamp, reported_date timestamp, description text, estimated_loss numeric, status text, settlement_amount numeric, settlement_date date, claim_handler_id text, police_report_number text )
CREATE TABLE insurance.insurance_products ( product_id text PRIMARY KEY, product_name text, product_type text, description text, base_premium numeric, coverage_details text, underwriting_rules text, is_active boolean, created_at timestamp, updated_at timestamp )
CREATE TABLE insurance.agents ( agent_id text PRIMARY KEY, first_name text, last_name text, agency_name text, license_number text, license_state text, contact_email text, contact_phone text, hire_date date, termination_date date, status text, commission_rate numeric, manager_id text )
CREATE TABLE insurance.policy_beneficiaries ( beneficiary_id text PRIMARY KEY, policy_id text, customer_id text, first_name text, last_name text, relationship text, percentage_share numeric, contact_info text, added_at timestamp )

[User] Show me all insurance products along with the number of distinct agents whose handled claims are for policies using that product. Include product_id, product_name, and agent_count.

[Assistant]
SELECT ip.product_id, ip.product_name, COUNT(DISTINCT c.claim_handler_id) AS agent_count
FROM insurance.insurance_products ip
JOIN insurance.claims c ON c.policy_id IN (
    SELECT policy_id FROM insurance.policy_beneficiaries WHERE policy_id IS NOT NULL
)
WHERE ip.product_id IS NOT NULL
GROUP BY ip.product_id, ip.product_name;

[User] Can you also add only products that are currently active and sort by agent_count descending?

[Assistant]
SELECT ip.product_id, ip.product_name, COUNT(DISTINCT c.claim_handler_id) AS agent_count
FROM insurance.insurance_products ip
JOIN insurance.claims c ON c.policy_id IN (
    SELECT policy_id FROM insurance.policy_beneficiaries WHERE policy_id IS NOT NULL
)
WHERE ip.is_active = true
GROUP BY ip.product_id, ip.product_name
ORDER BY agent_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 social_media.posts ( post_id text PRIMARY KEY, user_id text, content text, media_url text, media_type text, created_at timestamp, updated_at timestamp, visibility text, location_lat numeric, location_lon numeric )
CREATE TABLE social_media.follows (
    follow_id character varying(64) NOT NULL, -- unique identifier for the follow relationship
    follower_user_id character varying(64) NOT NULL, -- identifier of the user who is following (FK to users.user_id)
    following_user_id character varying(64) NOT NULL, -- identifier of the user being followed (FK to users.user_id)
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of when the follow started
    PRIMARY KEY (follow_id),
    CONSTRAINT unique_follow UNIQUE (follower_user_id, following_user_id) -- prevent duplicate follows
)
CREATE TABLE social_media.hashtags ( hashtag_id character varying(64) NOT NULL, tag_name character varying(100) NOT NULL UNIQUE, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (hashtag_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 character varying(64) NOT NULL, -- unique identifier for the message
    conversation_id character varying(64) NOT NULL, -- identifier for the conversation thread (FK to conversations.conversation_id)
    sender_user_id character varying(64) NOT NULL, -- identifier of the sender (FK to users.user_id)
    content text, -- textual content of the message
    media_url text, -- URL to attached media (image/video)
    media_type character varying(20), -- type of media ('image', 'video', null)
    sent_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when message was sent
    read_at timestamp, -- timestamp when message was read by recipient(s)
    PRIMARY KEY (message_id)
)
CREATE TABLE social_media.conversations ( conversation_id text PRIMARY KEY, created_at timestamp, last_message_at timestamp, is_group_chat bool, group_name text )
CREATE TABLE social_media.conversation_participants (
    participant_id character varying(64) NOT NULL, -- unique identifier for the participant entry
    conversation_id character varying(64) NOT NULL, -- identifier of the conversation (FK to conversations.conversation_id)
    user_id character varying(64) NOT NULL, -- identifier of the user in the conversation (FK to users.user_id)
    joined_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when user joined the conversation
    last_read_at timestamp, -- timestamp indicating up to when the user has read messages
    PRIMARY KEY (participant_id),
    CONSTRAINT unique_user_conversation UNIQUE (conversation_id, user_id) -- prevent user being added multiple times
)
CREATE TABLE social_media.notifications (
    notification_id character varying(64) NOT NULL, -- unique identifier for the notification
    recipient_user_id character varying(64) NOT NULL, -- user receiving the notification (FK to users.user_id)
    sender_user_id character varying(64), -- user triggering the notification (FK to users.user_id, can be null for system notifications)
    notification_type character varying(30) NOT NULL, -- type of notification ('like', 'comment', 'follow', 'mention', 'message')
    target_entity_id character varying(64), -- ID of the related entity (post_id, comment_id, user_id, conversation_id)
    target_entity_type character varying(20), -- type of the related entity ('post', 'comment', 'user', 'conversation')
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp notification was created
    read_at timestamp, -- timestamp notification was marked as read
    PRIMARY KEY (notification_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] Can you show me all followers of a given user, including their usernames and the date they started following?

[Assistant]
SELECT f.follower_user_id, u.username, f.created_at
FROM social_media.follows f
JOIN social_media.users u ON f.follower_user_id = u.user_id
WHERE f.following_user_id = :user_id;

[User] Now, only include followers who started following in the year 2024.

[Assistant]
SELECT f.follower_user_id, u.username, f.created_at
FROM social_media.follows f
JOIN social_media.users u ON f.follower_user_id = u.user_id
WHERE f.following_user_id = :user_id
  AND f.created_at >= '2024-01-01' AND f.created_at < '2025-01-01';

[User] Please also include their email addresses in the result.

[Assistant]
SELECT f.follower_user_id, u.username, u.email, f.created_at
FROM social_media.follows f
JOIN social_media.users u ON f.follower_user_id = u.user_id
WHERE f.following_user_id = :user_id
  AND f.created_at >= '2024-01-01' AND f.created_at < '2025-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 web3.tokens ( token_id character varying(64) NOT NULL, contract_address character varying(128) NOT NULL, token_name character varying(128) NOT NULL, token_symbol character varying(32) NOT NULL, decimals integer NOT NULL, total_supply numeric(38,14) NOT NULL, PRIMARY KEY (token_id) )

[User] List all pairs of tokens (show token_id for both) that share the same contract address, excluding pairs where the token_id is the same.

[Assistant] SELECT t1.token_id AS token_id1, t2.token_id AS token_id2, t1.contract_address FROM web3.tokens AS t1 JOIN web3.tokens AS t2 ON t1.contract_address = t2.contract_address WHERE t1.token_id < t2.token_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 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.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] List all customer-employee pairs where they share the same email domain, showing customer_id, customer email, employee_id, and employee email.

[Assistant]
SELECT c.customer_id,
       c.email AS customer_email,
       e.employee_id,
       e.email AS employee_email,
       SPLIT_PART(c.email, '@', 2) AS email_domain
FROM financial_services.customers c
JOIN financial_services.employees e
  ON SPLIT_PART(c.email, '@', 2) = SPLIT_PART(e.email, '@', 2);

[User] Actually, only include domains that appear for at least 3 customers.

[Assistant]
WITH domain_counts AS (
  SELECT SPLIT_PART(email, '@', 2) AS email_domain,
         COUNT(*) AS cust_count
  FROM financial_services.customers
  GROUP BY SPLIT_PART(email, '@', 2)
  HAVING COUNT(*) >= 3
)
SELECT c.customer_id,
       c.email AS customer_email,
       e.employee_id,
       e.email AS employee_email,
       dc.email_domain
FROM financial_services.customers c
JOIN financial_services.employees e
  ON SPLIT_PART(c.email, '@', 2) = SPLIT_PART(e.email, '@', 2)
JOIN domain_counts dc
  ON SPLIT_PART(c.email, '@', 2) = dc.email_domain;

[User] Now, order the results by the email_domain ascending and then by customer_last_name descending.

[Assistant]
WITH domain_counts AS (
  SELECT SPLIT_PART(email, '@', 2) AS email_domain,
         COUNT(*) AS cust_count
  FROM financial_services.customers
  GROUP BY SPLIT_PART(email, '@', 2)
  HAVING COUNT(*) >= 3
)
SELECT c.customer_id,
       c.email AS customer_email,
       e.employee_id,
       e.email AS employee_email,
       dc.email_domain
FROM financial_services.customers c
JOIN financial_services.employees e
  ON SPLIT_PART(c.email, '@', 2) = SPLIT_PART(e.email, '@', 2)
JOIN domain_counts dc
  ON SPLIT_PART(c.email, '@', 2) = dc.email_domain
ORDER BY dc.email_domain ASC,
         c.last_name DESC;


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

[User] List all customer_ids who have both a checking account and a savings account with a combined balance exceeding $50,000.

[Assistant] SELECT c.customer_id FROM financial_services.accounts c JOIN financial_services.accounts s ON c.customer_id = s.customer_id WHERE c.account_type = 'Checking' AND s.account_type = 'Savings' AND (c.balance + s.balance) > 50000 GROUP BY c.customer_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.medications ( medication_id character varying(64) NOT NULL, medication_name character varying(255) NOT NULL, generic_name character varying(255), manufacturer character varying(100), ndc_code character varying(20) UNIQUE, description text, PRIMARY KEY (medication_id) )

[User] Show the medication_id, medication_name, and manufacturer for all medication entries.

[Assistant] SELECT medication_id, medication_name, manufacturer FROM healthcare.medications;

[User] Filter to show only those where the manufacturer is specified (not null).

[Assistant] SELECT medication_id, medication_name, manufacturer FROM healthcare.medications WHERE manufacturer IS NOT NULL;

[User] Also, include only medications where the generic name contains 'acid'.

[Assistant] SELECT medication_id, medication_name, manufacturer FROM healthcare.medications WHERE manufacturer IS NOT NULL AND generic_name LIKE '%acid%';

[User] Can you add the NDC code to the result?

[Assistant] SELECT medication_id, medication_name, manufacturer, ndc_code FROM healthcare.medications WHERE manufacturer IS NOT NULL AND generic_name LIKE '%acid%';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE insurance.policies ( policy_id text, customer_id text, product_id text, agent_id text, policy_number text, start_date date, end_date date, premium_amount numeric, coverage_limit numeric, deductible numeric, status text, issued_at timestamp, cancellation_date date, cancellation_reason text )
CREATE TABLE insurance.claims ( claim_id text PRIMARY KEY, policy_id text, customer_id text, incident_date timestamp, reported_date timestamp, description text, estimated_loss numeric, status text, settlement_amount numeric, settlement_date date, claim_handler_id text, police_report_number text )
CREATE TABLE insurance.insurance_products ( product_id text PRIMARY KEY, product_name text, product_type text, description text, base_premium numeric, coverage_details text, underwriting_rules text, is_active boolean, created_at timestamp, updated_at timestamp )
CREATE TABLE insurance.premium_payments ( payment_id text, policy_id text, customer_id text, payment_date timestamp, amount_paid numeric, payment_method text, transaction_reference text, due_date date, payment_period_start date, payment_period_end date, status text )
CREATE TABLE insurance.claim_documents ( document_id text PRIMARY KEY, claim_id text, document_type text, file_name text, file_path text, file_size_bytes int, mime_type text, uploaded_by text, uploaded_at timestamp, description text )
CREATE TABLE insurance.policy_beneficiaries ( beneficiary_id text, policy_id text, customer_id text, first_name text, last_name text, relationship text, percentage_share numeric, contact_info text, added_at timestamp )

[User] Show me the customer ID, payment ID, payment amount, and payment date for all premium payments with an amount paid over 2000.

[Assistant]
SELECT customer_id, payment_id, amount_paid, payment_date
FROM insurance.premium_payments
WHERE amount_paid > 2000;


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 character varying(64) NOT NULL, property_id character varying(64) NOT NULL, service_name character varying(150) NOT NULL, description text, category character varying(100), price numeric(10, 2) NOT NULL, unit character varying(30), is_available boolean NOT NULL DEFAULT true, department character varying(100), PRIMARY KEY (service_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id) )

[User] Show me each department in each property, along with the total number of available services and their combined price.

[Assistant] SELECT property_id, department, COUNT(*) AS service_count, SUM(price) AS total_price FROM hospitality_technology.services WHERE is_available = true GROUP BY property_id, department;


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, username.text, email.text, password_hash.text, registration_date.timestamptz, last_login.timestamptz, country_code.text, status.text, profile_data.jsonb )
CREATE TABLE gaming_technology.games ( game_id.uuid, 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.developers ( developer_id.uuid, name.text, country.text, founded_year.integer, website.text, created_at.timestamptz )
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, player_id.uuid, achievement_id.uuid, unlocked_at.timestamptz )
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] Show me the items in player inventory for player ID 'abcdefgh-1234-5678-abcd-efghijklmnop'. List the item name and quantity.

[Assistant] SELECT ii.item_name, pi.quantity FROM gaming_technology.player_inventory pi JOIN gaming_technology.in_game_items ii ON pi.item_id = ii.item_id WHERE pi.player_id = 'abcdefgh-1234-5678-abcd-efghijklmnop';

[User] Could you also include the title of the game that each item belongs to?

[Assistant] SELECT g.title, ii.item_name, pi.quantity FROM gaming_technology.player_inventory pi JOIN gaming_technology.in_game_items ii ON pi.item_id = ii.item_id JOIN gaming_technology.games g ON ii.game_id = g.game_id WHERE pi.player_id = 'abcdefgh-1234-5678-abcd-efghijklmnop';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE government_services.agencies ( agency_id character varying(64) NOT NULL, agency_name character varying(255) NOT NULL, jurisdiction_level character varying(50) NOT NULL, primary_contact_email character varying(128), main_phone_number character varying(32), website_url character varying(255), established_date date, parent_agency_id character varying(64), PRIMARY KEY (agency_id) )

[User] List all agencies that do not have a website URL specified. Return their agency_id, agency_name, and main_phone_number.

[Assistant] SELECT agency_id, agency_name, main_phone_number FROM government_services.agencies WHERE website_url IS NULL OR website_url = '';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE insurance.customers ( customer_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, date_of_birth date NOT NULL, ssn_hash character varying(128), address_line1 character varying(255) NOT NULL, address_line2 character varying(255), city character varying(100) NOT NULL, state character varying(50) NOT NULL, zip_code character varying(20) NOT NULL, country character varying(50) NOT NULL DEFAULT 'USA', phone_number character varying(30), email character varying(128) UNIQUE, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at timestamp, status character varying(20) NOT NULL DEFAULT 'Active', PRIMARY KEY (customer_id) )
CREATE TABLE insurance.policies ( policy_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, product_id character varying(64) NOT NULL, agent_id character varying(64), policy_number character varying(100) NOT NULL UNIQUE, start_date date NOT NULL, end_date date NOT NULL, premium_amount numeric(12, 2) NOT NULL, coverage_limit numeric(15, 2) NOT NULL, deductible numeric(10, 2) NOT NULL, status character varying(30) NOT NULL, issued_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, cancellation_date date, cancellation_reason text, PRIMARY KEY (policy_id) )
CREATE TABLE insurance.insurance_products ( product_id character varying(64) NOT NULL, product_name character varying(150) NOT NULL, product_type character varying(50) NOT NULL, description text, base_premium numeric(10, 2) NOT NULL, coverage_details text, underwriting_rules text, is_active boolean NOT NULL DEFAULT true, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at timestamp, PRIMARY KEY (product_id) )
CREATE TABLE insurance.premium_payments ( payment_id character varying(64) NOT NULL, policy_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, payment_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, amount_paid numeric(12, 2) NOT NULL, payment_method character varying(50), transaction_reference character varying(128) UNIQUE, due_date date, payment_period_start date, payment_period_end date, status character varying(30) NOT NULL DEFAULT 'Completed', PRIMARY KEY (payment_id) )
CREATE TABLE insurance.policy_beneficiaries ( beneficiary_id character varying(64) NOT NULL, policy_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, relationship character varying(50) NOT NULL, percentage_share numeric(5, 2) NOT NULL CHECK (percentage_share > 0 AND percentage_share <= 100), contact_info text, added_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (beneficiary_id), UNIQUE (policy_id, customer_id) )

[User] Show me all customers who have purchased policies for insurance products of type 'health', including their full name, policy number, and the insurance product's name.

[Assistant]
SELECT c.customer_id, c.first_name, c.last_name, p.policy_number, ip.product_name
FROM insurance.customers c
JOIN insurance.policies p ON p.customer_id = c.customer_id
JOIN insurance.insurance_products ip ON ip.product_id = p.product_id
WHERE ip.product_type = 'health';

[User] Add the premium amount of the policy and the product's base premium to the result.

[Assistant]
SELECT c.customer_id, c.first_name, c.last_name, p.policy_number, ip.product_name, p.premium_amount, ip.base_premium
FROM insurance.customers c
JOIN insurance.policies p ON p.customer_id = c.customer_id
JOIN insurance.insurance_products ip ON ip.product_id = p.product_id
WHERE ip.product_type = 'health';

[User] Actually, only include policies that are currently active and have a premium amount greater than the base premium of the product.

[Assistant]
SELECT c.customer_id, c.first_name, c.last_name, p.policy_number, ip.product_name, p.premium_amount, ip.base_premium
FROM insurance.customers c
JOIN insurance.policies p ON p.customer_id = c.customer_id
JOIN insurance.insurance_products ip ON ip.product_id = p.product_id
WHERE ip.product_type = 'health'
  AND p.status = 'active'
  AND p.premium_amount > ip.base_premium;


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.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.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] For each citizen, show their citizen ID and the total number of applications and notifications they have.

[Assistant]
SELECT c.citizen_id,
       COALESCE(a.application_count, 0) AS application_count,
       COALESCE(n.notification_count, 0) AS notification_count
FROM (
    SELECT citizen_id FROM government_services.applications
    UNION
    SELECT citizen_id FROM government_services.notifications
) c
LEFT JOIN (
    SELECT citizen_id, COUNT(*) AS application_count
    FROM government_services.applications
    GROUP BY citizen_id
) a ON c.citizen_id = a.citizen_id
LEFT JOIN (
    SELECT citizen_id, COUNT(*) AS notification_count
    FROM government_services.notifications
    GROUP BY citizen_id
) n ON c.citizen_id = n.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 social_media.user_settings ( setting_id text PRIMARY KEY, user_id text, theme text, email_notifications_enabled bool, push_notifications_enabled bool, private_profile bool, updated_at timestamp )

[User] Can you show me the user IDs and their theme settings for all users who have enabled email notifications and have updated their settings in 2024?

[Assistant] SELECT user_id, theme FROM social_media.user_settings WHERE email_notifications_enabled = TRUE AND updated_at >= '2024-01-01';

[User] What if I also want to see if their profile is private or not?

[Assistant] SELECT user_id, theme, private_profile FROM social_media.user_settings WHERE email_notifications_enabled = TRUE AND updated_at >= '2024-01-01';

[User] Actually, I want to see users who have both email AND push notifications enabled.

[Assistant] SELECT user_id, theme, private_profile FROM social_media.user_settings WHERE email_notifications_enabled = TRUE AND push_notifications_enabled = TRUE AND updated_at >= '2024-01-01';

[User] Now, limit the results to users whose theme is 'light' only.

[Assistant] SELECT user_id, theme, private_profile FROM social_media.user_settings WHERE email_notifications_enabled = TRUE AND push_notifications_enabled = TRUE AND theme = 'light' AND updated_at >= '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 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)
)
CREATE TABLE government_services.agencies ( agency_id character varying(64) NOT NULL, agency_name character varying(255) NOT NULL, jurisdiction_level character varying(50) NOT NULL, primary_contact_email character varying(128), main_phone_number character varying(32), website_url character varying(255), established_date date, parent_agency_id character varying(64), PRIMARY KEY (agency_id) )
CREATE TABLE government_services.services (
    service_id character varying(64) NOT NULL, -- unique identifier for the service
    agency_id character varying(64) NOT NULL, -- FK to agencies table
    service_name character varying(255) NOT NULL, -- name of the service (e.g., Driver's License Renewal)
    description text,
    category character varying(100), -- e.g., Licensing, Benefits, Taxation, Permits
    eligibility_criteria text, -- description of who is eligible
    standard_fee numeric(10, 2) DEFAULT 0.00, -- typical fee for the service
    average_processing_time_days integer, -- estimated processing time
    is_active boolean DEFAULT true, -- whether the service is currently offered
    online_application_url character varying(255),
    PRIMARY KEY (service_id)
)
CREATE TABLE government_services.applications (
    application_id character varying(64) NOT NULL, -- unique identifier for the application
    citizen_id character varying(64) NOT NULL, -- FK to citizens table
    service_id character varying(64) NOT NULL, -- FK to services table
    submitted_at timestamp NOT NULL, -- time the application was submitted
    status character varying(50) NOT NULL, -- e.g., Submitted, Processing, Approved, Rejected, Pending Info
    last_updated_at timestamp NOT NULL, -- time the status or details last changed
    assigned_employee_id character varying(64), -- FK to employees table (optional)
    decision_date date, -- date when a final decision was made
    notes text, -- internal notes or citizen-provided comments
    reference_number character varying(100) UNIQUE, -- publicly visible reference number
    PRIMARY KEY (application_id)
)
CREATE TABLE government_services.documents ( document_id text PRIMARY KEY, application_id text, citizen_id text, document_type text, file_reference text, upload_timestamp timestamp, expiry_date date, verification_status text, verified_by_employee_id text, verification_timestamp timestamp )
CREATE TABLE government_services.payments ( payment_id text, application_id text, citizen_id text, service_id text, amount numeric, currency text, payment_method text, payment_provider_reference text, payment_timestamp timestamp, status text, notes text )
CREATE TABLE government_services.employees (
    employee_id character varying(64) NOT NULL, -- unique identifier for the government employee
    agency_id character varying(64) NOT NULL, -- FK to agencies table
    first_name character varying(100) NOT NULL,
    last_name character varying(100) NOT NULL,
    job_title character varying(150) NOT NULL,
    department character varying(100),
    work_email character varying(128) NOT NULL UNIQUE,
    work_phone character varying(32),
    hire_date date NOT NULL,
    termination_date date, -- null if currently employed
    access_level character varying(50), -- Role or permission level
    manager_employee_id character varying(64), -- FK to self for reporting structure
    PRIMARY KEY (employee_id)
)
CREATE TABLE government_services.appointments ( appointment_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, employee_id character varying(64), location_id character varying(64), service_id character varying(64), scheduled_start_time timestamp NOT NULL, scheduled_end_time timestamp, purpose text NOT NULL, status character varying(30) NOT NULL, booking_method character varying(50), created_at timestamp NOT NULL, notes text, PRIMARY KEY (appointment_id) )

[User] How many services are defined for each service category?

[Assistant] SELECT category, COUNT(*) AS service_count FROM government_services.services GROUP BY category;

[User] Only show categories that have more than 15 services listed.

[Assistant] SELECT category, COUNT(*) AS service_count FROM government_services.services GROUP BY category HAVING COUNT(*) > 15;

[User] Could you only count services that are currently marked as active?

[Assistant] SELECT category, COUNT(*) AS service_count FROM government_services.services WHERE is_active = true GROUP BY category HAVING COUNT(*) > 15;

[User] Also, for these categories, provide the average standard fee for the active services.

[Assistant] SELECT category, COUNT(*) AS service_count, AVG(standard_fee) AS average_fee FROM government_services.services WHERE is_active = true GROUP BY category HAVING COUNT(*) > 15;


[User] For each agency that is a parent, how many direct child agencies does it have? Show the parent agency name and the count.

[Assistant] SELECT parent.agency_name AS parent_agency_name, COUNT(child.agency_id) AS child_agency_count FROM government_services.agencies AS parent INNER JOIN government_services.agencies AS child ON parent.agency_id = child.parent_agency_id GROUP BY parent.agency_id, parent.agency_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 healthcare.patients ( patient_id text PRIMARY KEY, first_name text, last_name text, date_of_birth date, gender text, address text, phone_number text, email text, emergency_contact_name text, emergency_contact_phone text, created_at timestamp, updated_at timestamp )
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 )
CREATE TABLE healthcare.medical_records ( record_id text PRIMARY KEY, patient_id text, appointment_id text, doctor_id text, record_date timestamp, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals text, created_at timestamp )
CREATE TABLE healthcare.diagnoses ( diagnosis_id text PRIMARY KEY, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )

[User] How many patients are there in each gender category?

[Assistant]
SELECT gender,
       COUNT(*) AS patient_count
FROM healthcare.patients
GROUP BY gender;

[User] Limit this to categories with more than 50 patients.

[Assistant]
SELECT gender,
       COUNT(*) AS patient_count
FROM healthcare.patients
GROUP BY gender
HAVING COUNT(*) > 50;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE transportation.vehicles ( vehicle_id text PRIMARY KEY, license_plate text, vin text, make text, model text, year int, type text, capacity int, fuel_type text, status text, depot_id text, acquisition_date date )
CREATE TABLE transportation.drivers ( driver_id text PRIMARY KEY, employee_id text, first_name text, last_name text, license_number text, license_expiry_date date, contact_number text, email text, hire_date date, status text )
CREATE TABLE transportation.routes ( route_id text PRIMARY KEY, route_number text, description text, origin_location_id text, destination_location_id text, distance_km numeric, estimated_duration_minutes int, type text )
CREATE TABLE transportation.trips ( trip_id text PRIMARY KEY, route_id text, vehicle_id text, driver_id text, scheduled_departure timestamp, actual_departure timestamp, scheduled_arrival timestamp, actual_arrival timestamp, origin_location_id text, destination_location_id text, status text, passenger_count int, cargo_manifest_id text )
CREATE TABLE transportation.locations ( location_id text PRIMARY KEY, name text, type text, address_line1 text, city text, state_province text, postal_code text, country text, latitude numeric, longitude numeric, timezone text )
CREATE TABLE transportation.maintenance_logs ( log_id text PRIMARY KEY, vehicle_id text, service_date date, odometer_reading int, service_type text, description text, cost numeric, mechanic_name text, next_service_due_date date )
CREATE TABLE transportation.fuel_logs ( fuel_log_id text PRIMARY KEY, vehicle_id text, trip_id text, log_timestamp timestamp, fuel_type text, quantity numeric, unit text, cost_per_unit numeric, total_cost numeric, odometer_reading int, location_id text )
CREATE TABLE transportation.bookings ( booking_id text PRIMARY KEY, passenger_id text, trip_id text, seat_number text, booking_time timestamp, status text, fare numeric, payment_transaction_id text, special_requests text )

[User] Retrieve the vehicle_id, make, model, and the next_service_due_date for each vehicle based on the most recent maintenance log.

[Assistant] SELECT DISTINCT ON (ml.vehicle_id) v.vehicle_id, v.make, v.model, ml.next_service_due_date FROM transportation.maintenance_logs ml JOIN transportation.vehicles v ON v.vehicle_id = ml.vehicle_id ORDER BY ml.vehicle_id, ml.service_date DESC;

[User] Now, only include vehicles with status 'Active' and whose next_service_due_date is within the next 30 days, ordering by next_service_due_date ascending.

[Assistant] SELECT v.vehicle_id, v.make, v.model, ml.next_service_due_date FROM transportation.vehicles v JOIN (SELECT DISTINCT ON (vehicle_id) vehicle_id, next_service_due_date FROM transportation.maintenance_logs ORDER BY vehicle_id, service_date DESC) ml ON v.vehicle_id = ml.vehicle_id WHERE v.status = 'Active' AND ml.next_service_due_date BETWEEN current_date AND current_date + INTERVAL '30 days' ORDER BY ml.next_service_due_date ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE 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) )

[User] Can you list for each player their most recent and second most recent achievements, showing columns player_id, recent_achievement_id, second_recent_achievement_id, and recent_unlocked_at?

[Assistant]
SELECT recent.player_id,
       recent.achievement_id AS recent_achievement_id,
       prev.achievement_id AS second_recent_achievement_id,
       recent.unlocked_at AS recent_unlocked_at
FROM (
  SELECT player_id, achievement_id, unlocked_at,
         ROW_NUMBER() OVER (PARTITION BY player_id ORDER BY unlocked_at DESC) AS rn
  FROM gaming_technology.player_achievements
) recent
JOIN (
  SELECT player_id, achievement_id,
         ROW_NUMBER() OVER (PARTITION BY player_id ORDER BY unlocked_at DESC) AS rn
  FROM gaming_technology.player_achievements
) prev
  ON recent.player_id = prev.player_id
WHERE recent.rn = 1 AND prev.rn = 2;

[User] Actually, please exclude any players who have less than two unlock records.

[Assistant]
WITH ranked AS (
  SELECT player_id, achievement_id, unlocked_at,
         ROW_NUMBER() OVER (PARTITION BY player_id ORDER BY unlocked_at DESC) AS rn,
         COUNT(*) OVER (PARTITION BY player_id) AS cnt
  FROM gaming_technology.player_achievements
)
SELECT recent.player_id,
       recent.achievement_id AS recent_achievement_id,
       prev.achievement_id AS second_recent_achievement_id,
       recent.unlocked_at AS recent_unlocked_at
FROM ranked recent
JOIN ranked prev
  ON recent.player_id = prev.player_id
WHERE recent.rn = 1
  AND prev.rn = 2
  AND recent.cnt >= 2;

[User] Also include the unlocked_at timestamp of the second most recent achievement.

[Assistant]
WITH ranked AS (
  SELECT player_id, achievement_id, unlocked_at,
         ROW_NUMBER() OVER (PARTITION BY player_id ORDER BY unlocked_at DESC) AS rn,
         COUNT(*) OVER (PARTITION BY player_id) AS cnt
  FROM gaming_technology.player_achievements
)
SELECT recent.player_id,
       recent.achievement_id AS recent_achievement_id,
       recent.unlocked_at AS recent_unlocked_at,
       prev.achievement_id AS second_recent_achievement_id,
       prev.unlocked_at AS second_recent_unlocked_at
FROM ranked recent
JOIN ranked prev
  ON recent.player_id = prev.player_id
WHERE recent.rn = 1
  AND prev.rn = 2
  AND recent.cnt >= 2;

[User] Finally, order the output by recent_unlocked_at in descending order.

[Assistant]
WITH ranked AS (
  SELECT player_id, achievement_id, unlocked_at,
         ROW_NUMBER() OVER (PARTITION BY player_id ORDER BY unlocked_at DESC) AS rn,
         COUNT(*) OVER (PARTITION BY player_id) AS cnt
  FROM gaming_technology.player_achievements
)
SELECT recent.player_id,
       recent.achievement_id AS recent_achievement_id,
       recent.unlocked_at AS recent_unlocked_at,
       prev.achievement_id AS second_recent_achievement_id,
       prev.unlocked_at AS second_recent_unlocked_at
FROM ranked recent
JOIN ranked prev
  ON recent.player_id = prev.player_id
WHERE recent.rn = 1 AND prev.rn = 2 AND recent.cnt >= 2
ORDER BY recent.unlocked_at DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE gaming_technology.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 )

[User] I want to see for each server region the total number of servers and the average duration of all sessions hosted in that region.

[Assistant] SELECT s.region, COUNT(DISTINCT s.server_id) AS server_count, AVG(gs.duration_seconds) AS avg_duration FROM gaming_technology.servers s JOIN gaming_technology.game_sessions gs ON s.server_id = gs.server_id GROUP BY s.region;

[User] Actually, can you filter so that only regions with more than 200 sessions are included?

[Assistant] SELECT s.region, COUNT(DISTINCT s.server_id) AS server_count, AVG(gs.duration_seconds) AS avg_duration FROM gaming_technology.servers s JOIN gaming_technology.game_sessions gs ON s.server_id = gs.server_id GROUP BY s.region HAVING COUNT(gs.session_id) > 200;

[User] Also exclude any sessions that have a NULL end_time.

[Assistant] SELECT s.region, COUNT(DISTINCT s.server_id) AS server_count, AVG(gs.duration_seconds) AS avg_duration FROM gaming_technology.servers s JOIN gaming_technology.game_sessions gs ON s.server_id = gs.server_id WHERE gs.end_time IS NOT NULL GROUP BY s.region HAVING COUNT(gs.session_id) > 200;

[User] Finally, sort the results by average session duration in descending order.

[Assistant] SELECT s.region, COUNT(DISTINCT s.server_id) AS server_count, AVG(gs.duration_seconds) AS avg_duration FROM gaming_technology.servers s JOIN gaming_technology.game_sessions gs ON s.server_id = gs.server_id WHERE gs.end_time IS NOT NULL GROUP BY s.region HAVING COUNT(gs.session_id) > 200 ORDER BY avg_duration DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.users ( user_id text PRIMARY KEY, username text, email text, password_hash text, created_at timestamp )
CREATE TABLE trading_platform.wallets ( wallet_id text PRIMARY KEY, user_id text, address text, private_key text, created_at timestamp )
CREATE TABLE trading_platform.orders ( order_id text PRIMARY KEY, user_id text, wallet_id text, asset_id text, order_type text, quantity numeric, price numeric, status text, created_at timestamp )
CREATE TABLE trading_platform.trades ( trade_id text PRIMARY KEY, order_id text, buyer_id text, seller_id text, asset_id text, quantity numeric, price numeric, traded_at timestamp )
CREATE TABLE trading_platform.utxos ( utxo_id text PRIMARY KEY, transaction_id text, output_index int, address text, amount numeric, spent boolean )
CREATE TABLE trading_platform.peers ( peer_id text PRIMARY KEY, ip_address text, port int, last_seen timestamp )
CREATE TABLE trading_platform.metadata ( metadata_id text PRIMARY KEY, asset_id text, key text, value text )
CREATE TABLE trading_platform.kyc_audit ( kyc_audit_id text PRIMARY KEY, user_id text, status text, reviewed_at timestamp )
CREATE TABLE trading_platform.logs ( log_id text PRIMARY KEY, user_id text, action text, details text, logged_at timestamp )
CREATE TABLE trading_platform.notifications ( notification_id text PRIMARY KEY, user_id text, message text, sent_at timestamp, read_at timestamp )

[User] Provide a summary for each transaction ID, showing the total amount of all its unspent UTXOs.

[Assistant] SELECT transaction_id, SUM(amount) FROM utxos WHERE spent = false GROUP BY transaction_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 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.staff ( staff_id text PRIMARY KEY, 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 int, manager_id text, created_at timestamp )
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 )
CREATE TABLE hospitality_technology.reviews ( review_id text, property_id text, reservation_id text, guest_id text, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source text, review_date timestamp, is_public boolean, staff_response text, response_staff_id text, response_date timestamp )

[User] Retrieve the number of distinct guests for each service order status.

[Assistant]
SELECT status, COUNT(DISTINCT guest_id) AS guest_count
FROM hospitality_technology.service_orders
GROUP BY status;

[User] Actually, only show statuses where the number of distinct guests is at least 50.

[Assistant]
SELECT status, COUNT(DISTINCT guest_id) AS guest_count
FROM hospitality_technology.service_orders
GROUP BY status
HAVING COUNT(DISTINCT guest_id) >= 50;


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.text, project_id.text, project_name.text, rounds_name.text, investment_value.numeric, investment_date.text, introduction.text, valuation.numeric )
CREATE TABLE token_basic_info ( coin_id.text, token_name.text, token_symbol.text, token_address.text, chain.text, price.numeric, price_change_percentage_1h.numeric, price_change_percentage_24h.numeric, price_change_percentage_7d.numeric, highest_price_24h.numeric, lowest_price_24h.numeric, market_cap.numeric, market_cap_rank.numeric, market_cap_change_percentage_24h.text, total_volume.text, narrative.text, trend_rank.numeric )
CREATE TABLE token_dexpool_info ( pair_address.text, token_name.text, token_symbol.text, chain.text, price.numeric, price_change_percentage_1h.numeric, price_change_percentage_6h.numeric, price_change_percentage_24h.numeric, makers_24h.numeric, volume_24h.numeric, liquidity.numeric, market_cap.numeric, trend_rank.numeric )
CREATE TABLE cex_token_balance ( snapshot_time.text, chain.text, address.text, exchange.text, token_address.text, token_symbol.text, balance.numeric, usd_value.numeric, price.numeric )
CREATE TABLE smart_money_token_inflow ( token_address.text, token_symbol.text, token_amount.numeric, usd_value.numeric, avg_price.numeric, type.numeric, address_amount.numeric, narrative.text, chain.text )

[User] What is the total USD value of tokens held by CEXes for tokens belonging to the 'DeFi' narrative on the 'Ethereum' chain? Show the narrative, chain, and total value.

[Assistant] SELECT T2.narrative, T1.chain, SUM(T1.usd_value) AS total_usd_value FROM cex_token_balance AS T1 JOIN token_basic_info AS T2 ON T1.token_symbol = T2.token_symbol WHERE T2.narrative = 'DeFi' AND T1.chain = 'Ethereum' GROUP BY T2.narrative, T1.chain;

[User] Instead of just 'DeFi' on 'Ethereum', show the top 5 narratives with the highest total USD value across *all* chains in CEX balances. Also include the count of distinct token symbols for each narrative.

[Assistant] SELECT T2.narrative, SUM(T1.usd_value) AS total_usd_value, COUNT(DISTINCT T1.token_symbol) AS token_count FROM cex_token_balance AS T1 JOIN token_basic_info AS T2 ON T1.token_symbol = T2.token_symbol WHERE T2.narrative IS NOT NULL GROUP BY T2.narrative ORDER BY total_usd_value DESC LIMIT 5;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.invoices (
    invoice_id character varying(64) NOT NULL,  -- unique identifier for the invoice
    invoice_number character varying(100) UNIQUE NOT NULL, -- user-facing invoice number
    client_id character varying(64) NOT NULL, -- FK to clients table
    case_id character varying(64), -- FK to cases table (optional, could be general retainer)
    issue_date date NOT NULL, -- date the invoice was generated
    due_date date NOT NULL, -- date the payment is due
    total_amount numeric(12, 2) NOT NULL, -- total amount due on the invoice
    amount_paid numeric(12, 2) DEFAULT 0.00, -- amount already paid
    status character varying(50) NOT NULL, -- e.g., Draft, Sent, Paid, Partially Paid, Overdue, Void
    payment_date timestamp, -- date the invoice was fully paid (nullable)
    notes text, -- additional notes or terms on the invoice
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (invoice_id)
)

[User] List pairs of invoice_number for invoices that share the same due_date.

[Assistant]
SELECT a.due_date,
       a.invoice_number AS invoice1,
       b.invoice_number AS invoice2
FROM legal_services.invoices a
JOIN legal_services.invoices b
  ON a.due_date = b.due_date
  AND a.invoice_id < b.invoice_id;

[User] Only include pairs where the due_date is in March 2024.

[Assistant]
SELECT a.due_date,
       a.invoice_number AS invoice1,
       b.invoice_number AS invoice2
FROM legal_services.invoices a
JOIN legal_services.invoices b
  ON a.due_date = b.due_date
  AND a.invoice_id < b.invoice_id
WHERE a.due_date BETWEEN '2024-03-01' AND '2024-03-31';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE hospitality_technology.reviews ( review_id text PRIMARY KEY, property_id text, reservation_id text, guest_id text, rating_overall int, rating_cleanliness int, rating_service int, rating_location int, rating_value int, comment text, review_source text, review_date timestamp, is_public boolean, staff_response text, response_staff_id text, response_date timestamp )

[User] Show me the full names of guests who reviewed property 'P005' and gave an overall rating of 5.

[Assistant] SELECT T1.first_name, T1.last_name FROM guests AS T1 JOIN reviews AS T2 ON T1.guest_id = T2.guest_id WHERE T2.property_id = 'P005' AND T2.rating_overall = 5;

[User] Now, also include their loyalty member ID and filter to only include guests from 'USA'.

[Assistant] SELECT T1.first_name, T1.last_name, T1.loyalty_member_id FROM guests AS T1 JOIN reviews AS T2 ON T1.guest_id = T2.guest_id WHERE T2.property_id = 'P005' AND T2.rating_overall = 5 AND T1.country = 'USA';


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

[User] Can you show me the number of unique item types and the average cost amount for each game?

[Assistant] SELECT game_id, COUNT(DISTINCT item_type) AS unique_item_types, AVG(cost_amount) AS avg_cost_amount FROM gaming_technology.in_game_items GROUP BY game_id;

[User] Actually, can you also include the item rarity with the highest average cost for each game?

[Assistant] SELECT game_id, COUNT(DISTINCT item_type) AS unique_item_types, AVG(cost_amount) AS avg_cost_amount, (SELECT rarity FROM gaming_technology.in_game_items i2 WHERE i2.game_id = i1.game_id GROUP BY rarity ORDER BY AVG(cost_amount) DESC LIMIT 1) AS highest_avg_cost_rarity FROM gaming_technology.in_game_items i1 GROUP BY game_id;

[User] Limit the results to games that have at least 3 different item types.

[Assistant] SELECT game_id, unique_item_types, avg_cost_amount, highest_avg_cost_rarity FROM (SELECT game_id, COUNT(DISTINCT item_type) AS unique_item_types, AVG(cost_amount) AS avg_cost_amount, (SELECT rarity FROM gaming_technology.in_game_items i2 WHERE i2.game_id = i1.game_id GROUP BY rarity ORDER BY AVG(cost_amount) DESC LIMIT 1) AS highest_avg_cost_rarity FROM gaming_technology.in_game_items i1 GROUP BY game_id) sub WHERE unique_item_types >= 3;

[User] Order the results by average cost amount in descending order.

[Assistant] SELECT game_id, unique_item_types, avg_cost_amount, highest_avg_cost_rarity FROM (SELECT game_id, COUNT(DISTINCT item_type) AS unique_item_types, AVG(cost_amount) AS avg_cost_amount, (SELECT rarity FROM gaming_technology.in_game_items i2 WHERE i2.game_id = i1.game_id GROUP BY rarity ORDER BY AVG(cost_amount) DESC LIMIT 1) AS highest_avg_cost_rarity FROM gaming_technology.in_game_items i1 GROUP BY game_id) sub WHERE unique_item_types >= 3 ORDER BY avg_cost_amount DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE social_media.users ( user_id text PRIMARY KEY, 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 bool )
CREATE TABLE social_media.follows ( follow_id text PRIMARY KEY, follower_user_id text, following_user_id text, created_at timestamp )
CREATE TABLE social_media.post_hashtags ( post_hashtag_id text PRIMARY KEY, post_id text, hashtag_id text )
CREATE TABLE social_media.conversations ( conversation_id text PRIMARY KEY, created_at timestamp, last_message_at timestamp, is_group_chat bool, group_name text )
CREATE TABLE social_media.user_settings ( setting_id text PRIMARY KEY, user_id text, theme text, email_notifications_enabled bool, push_notifications_enabled bool, private_profile bool, updated_at timestamp )

[User] List each hashtag_id along with the total number of distinct posts it's linked to.

[Assistant]
SELECT hashtag_id, COUNT(DISTINCT post_id) AS post_count
FROM social_media.post_hashtags
GROUP BY hashtag_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 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 )

[User] I want to see pairs of items from the same game that share the same rarity but are of different types. Show each pair's names and types.

[Assistant]
SELECT a.game_id,
       a.item_name AS item1_name,
       a.item_type AS item1_type,
       b.item_name AS item2_name,
       b.item_type AS item2_type
FROM gaming_technology.in_game_items a
JOIN gaming_technology.in_game_items b
  ON a.game_id = b.game_id
 AND a.rarity = b.rarity
 AND a.item_type <> b.item_type
 AND a.item_id < b.item_id;

[User] Also include cost_currency and cost_amount for each item in the output.

[Assistant]
SELECT a.game_id,
       a.item_name AS item1_name,
       a.item_type AS item1_type,
       a.cost_currency AS item1_currency,
       a.cost_amount   AS item1_cost,
       b.item_name AS item2_name,
       b.item_type AS item2_type,
       b.cost_currency AS item2_currency,
       b.cost_amount   AS item2_cost
FROM gaming_technology.in_game_items a
JOIN gaming_technology.in_game_items b
  ON a.game_id = b.game_id
 AND a.rarity = b.rarity
 AND a.item_type <> b.item_type
 AND a.item_id < b.item_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 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 cex_token_balance ( snapshot_time character varying(32) NOT NULL,  -- the snapshot time of record, converted from original timestamp chain character varying(128) NOT NULL, -- the chain that the token resides address character varying(128) NOT NULL, -- the address that holds the assets, owned by a CEX exchange character varying(512) NOT NULL, -- a centralized exchange name token_address character varying(128) NOT NULL, -- token contract address token_symbol character varying(512), --token symbol balance numeric(38,10), -- token balance usd_value numeric(38,14), -- value of the token held in USD price double precision, --price of the token in USD ,PRIMARY KEY (snapshot_time, exchange, address, chain, token_address) )
CREATE TABLE smart_money_token_performance ( token_address.text, token_symbol.text, pnl.numeric, net_flow.numeric, avg_cost.numeric, price.numeric, realized_ratio.numeric, roi.numeric, chain.text )

[User] List tokens on the 'Arbitrum' chain with a 24-hour price change percentage greater than 10% and a market cap above 1,000,000 USD. Show their symbol, name, price, 24-hour change percentage, and market cap. Order the results by the 24-hour change percentage in descending order.

[Assistant] SELECT token_symbol, token_name, price, price_change_percentage_24h, market_cap FROM token_basic_info WHERE chain = 'Arbitrum' AND price_change_percentage_24h > 10 AND market_cap > 1000000 ORDER BY price_change_percentage_24h 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.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.likes ( like_id.text, user_id.text, post_id.text, comment_id.text, created_at.timestamp )
CREATE TABLE social_media.hashtags ( hashtag_id character varying(64) NOT NULL, tag_name character varying(100) NOT NULL UNIQUE, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (hashtag_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.conversations (
    conversation_id character varying(64) NOT NULL, -- unique identifier for the conversation
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when conversation was initiated
    last_message_at timestamp, -- timestamp of the last message in the conversation
    is_group_chat boolean NOT NULL DEFAULT false, -- indicates if it's a group chat or direct message
    group_name character varying(100), -- name of the group chat (if applicable)
    PRIMARY KEY (conversation_id)
)
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 )

[User] I want to see each user's username and the number of posts they've made that include a media attachment of type 'image'.

[Assistant]
SELECT u.username, COUNT(*) AS image_post_count
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_type = 'image'
GROUP BY u.username;

[User] Only include users with more than 2 image posts.

[Assistant]
SELECT u.username, COUNT(*) AS image_post_count
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_type = 'image'
GROUP BY u.username
HAVING COUNT(*) > 2;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE 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.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.in_game_items ( item_id uuid NOT NULL DEFAULT gen_random_uuid(), game_id uuid NOT NULL, item_name character varying(150) NOT NULL, item_type character varying(50) NOT NULL, description text, rarity character varying(30), cost_currency character varying(10), cost_amount numeric(12, 2), attributes jsonb, PRIMARY KEY (item_id) )
CREATE TABLE gaming_technology.player_inventory ( inventory_id uuid NOT NULL DEFAULT gen_random_uuid(), player_id uuid NOT NULL, item_id uuid NOT NULL, quantity integer NOT NULL DEFAULT 1, acquired_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, instance_data jsonb, PRIMARY KEY (inventory_id) )

[User] Can you list all item names and their types from the in-game items table?

[Assistant] SELECT item_name, item_type FROM gaming_technology.in_game_items;

[User] Please filter this to only include items with 'Rare' or 'Legendary' rarity.

[Assistant] SELECT item_name, item_type FROM gaming_technology.in_game_items WHERE rarity IN ('Rare', 'Legendary');

[User] Also include the cost amount and cost currency for these items.

[Assistant] SELECT item_name, item_type, cost_amount, cost_currency FROM gaming_technology.in_game_items WHERE rarity IN ('Rare', 'Legendary');

[User] Can you only show items where the cost amount is greater than 0 and order by cost amount descending?

[Assistant] SELECT item_name, item_type, cost_amount, cost_currency FROM gaming_technology.in_game_items WHERE rarity IN ('Rare', 'Legendary') AND cost_amount > 0 ORDER BY cost_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 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.applications ( application_id text, citizen_id text, service_id text, submitted_at timestamp, status text, last_updated_at timestamp, assigned_employee_id text, decision_date date, notes text, reference_number text )
CREATE TABLE government_services.documents ( document_id.text, application_id.text, citizen_id.text, document_type.text, file_reference.text, upload_timestamp.timestamp, expiry_date.date, verification_status.text, verified_by_employee_id.text, verification_timestamp.timestamp )
CREATE TABLE government_services.payments ( payment_id text PRIMARY KEY, application_id text, citizen_id text, service_id text, amount numeric, currency text, payment_method text, payment_provider_reference text, payment_timestamp timestamp, status text, notes text )
CREATE TABLE government_services.service_locations ( location_id character varying(64) NOT NULL, agency_id character varying(64) NOT NULL, location_name character varying(200), address text NOT NULL, city character varying(100), state character varying(50), postal_code character varying(20), latitude numeric(9, 6), longitude numeric(9, 6), operating_hours text, contact_phone character varying(32), is_accessible boolean, PRIMARY KEY (location_id) )
CREATE TABLE government_services.notifications ( notification_id text PRIMARY KEY, 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] List all agencies and their main phone numbers.

[Assistant] SELECT agency_name, main_phone_number FROM government_services.agencies;

[User] Now show me the service locations associated with each of these agencies, including the location name and city.

[Assistant] SELECT a.agency_name, sl.location_name, sl.city FROM government_services.agencies AS a JOIN government_services.service_locations AS sl ON a.agency_id = sl.agency_id;

[User] Only include locations that are marked as accessible.

[Assistant] SELECT a.agency_name, sl.location_name, sl.city FROM government_services.agencies AS a JOIN government_services.service_locations AS sl ON a.agency_id = sl.agency_id WHERE sl.is_accessible = TRUE;

[User] And only for agencies with a jurisdiction level of 'Municipal'.

[Assistant] SELECT a.agency_name, sl.location_name, sl.city FROM government_services.agencies AS a JOIN government_services.service_locations AS sl ON a.agency_id = sl.agency_id WHERE sl.is_accessible = TRUE AND a.jurisdiction_level = 'Municipal';


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

[User] Show me all SUI NFTs with status 'exists' and their name and owner.

[Assistant] SELECT object_id, name, owner FROM sui_nfts WHERE status = 'exists';

[User] Also include the collection type and package ID for each NFT.

[Assistant] SELECT object_id, name, owner, collection_type, package_id FROM sui_nfts WHERE status = 'exists';

[User] Now only show NFTs where the collection_type starts with 'Dragon'.

[Assistant] SELECT object_id, name, owner, collection_type, package_id FROM sui_nfts WHERE status = 'exists' AND collection_type LIKE 'Dragon%';

[User] Include the display field in the output and order the result by name ascending.

[Assistant] SELECT object_id, name, owner, collection_type, package_id, display FROM sui_nfts WHERE status = 'exists' AND collection_type LIKE 'Dragon%' ORDER BY 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 government_services.agencies (
    agency_id character varying(64) NOT NULL, -- unique identifier for the agency
    agency_name character varying(255) NOT NULL, -- full name of the government agency
    jurisdiction_level character varying(50) NOT NULL, -- e.g., Federal, State, County, City
    primary_contact_email character varying(128),
    main_phone_number character varying(32),
    website_url character varying(255),
    established_date date,
    parent_agency_id character varying(64), -- FK to self for hierarchical structure
    PRIMARY KEY (agency_id)
)
CREATE TABLE government_services.services (
    service_id character varying(64) NOT NULL, -- unique identifier for the service
    agency_id character varying(64) NOT NULL, -- FK to agencies table
    service_name character varying(255) NOT NULL, -- name of the service (e.g., Driver's License Renewal)
    description text,
    category character varying(100), -- e.g., Licensing, Benefits, Taxation, Permits
    eligibility_criteria text, -- description of who is eligible
    standard_fee numeric(10, 2) DEFAULT 0.00, -- typical fee for the service
    average_processing_time_days integer, -- estimated processing time
    is_active boolean DEFAULT true, -- whether the service is currently offered
    online_application_url character varying(255),
    PRIMARY KEY (service_id)
)
CREATE TABLE government_services.applications (
    application_id character varying(64) NOT NULL, -- unique identifier for the application
    citizen_id character varying(64) NOT NULL, -- FK to citizens table
    service_id character varying(64) NOT NULL, -- FK to services table
    submitted_at timestamp NOT NULL, -- time the application was submitted
    status character varying(50) NOT NULL, -- e.g., Submitted, Processing, Approved, Rejected, Pending Info
    last_updated_at timestamp NOT NULL, -- time the status or details last changed
    assigned_employee_id character varying(64), -- FK to employees table (optional)
    decision_date date, -- date when a final decision was made
    notes text, -- internal notes or citizen-provided comments
    reference_number character varying(100) UNIQUE, -- publicly visible reference number
    PRIMARY KEY (application_id)
)

[User] Which agencies offer more than three services? List the agency ID and the total number of services they provide.

[Assistant]
SELECT agency_id, COUNT(service_id) AS total_services
FROM government_services.services
GROUP BY agency_id
HAVING COUNT(service_id) > 3;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.accounts ( account_id text, customer_id text, account_number text, account_type text, balance numeric, currency text, opened_date date, status text, interest_rate numeric, last_updated_at timestamp )
CREATE TABLE financial_services.transactions (
    transaction_id character varying(64) NOT NULL, -- unique identifier for the transaction
    account_id character varying(64) NOT NULL, -- account involved in the transaction
    related_account_id character varying(64), -- counterpart account for transfers
    transaction_type character varying(50) NOT NULL, -- e.g., Deposit, Withdrawal, Transfer, Payment, Fee, Interest
    amount numeric(19, 4) NOT NULL, -- transaction amount
    currency character varying(3) NOT NULL, -- transaction currency
    transaction_date timestamp NOT NULL, -- exact time of the transaction
    effective_date date NOT NULL, -- date the transaction affects the balance
    description text, -- description or memo of the transaction
    status character varying(32) NOT NULL, -- e.g., Pending, Completed, Failed, Reversed
    reference_number character varying(128), -- external reference if applicable (e.g., check number)
    PRIMARY KEY (transaction_id),
    FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id),
    FOREIGN KEY (related_account_id) REFERENCES financial_services.accounts(account_id)
)
CREATE TABLE financial_services.trades ( trade_id text PRIMARY KEY, account_id text, security_id text, order_id text, trade_type text, quantity numeric, price_per_unit numeric, total_amount numeric, commission numeric, trade_timestamp timestamp, settlement_date date, status text, execution_venue text )
CREATE TABLE financial_services.market_data ( data_point_id.bigint, security_id.text, data_timestamp.timestamp, open_price.numeric, high_price.numeric, low_price.numeric, close_price.numeric, adjusted_close_price.numeric, volume.bigint, source.text )
CREATE TABLE financial_services.employees (
    employee_id character varying(64) NOT NULL,  -- unique identifier for the employee
    first_name character varying(100) NOT NULL,
    last_name character varying(100) NOT NULL,
    job_title character varying(100) NOT NULL, -- e.g., Teller, Branch Manager, Financial Advisor, Analyst
    department character varying(100), -- e.g., Retail Banking, Wealth Management, IT
    branch_id character varying(64), -- Identifier for the branch they work at (if applicable)
    email character varying(128) NOT NULL UNIQUE,
    phone_extension character varying(20),
    hire_date date NOT NULL,
    termination_date date, -- Date of termination, null if currently employed
    manager_id character varying(64), -- Self-referencing key for manager relationship
    status character varying(32) NOT NULL, -- e.g., Active, Terminated, On Leave
    PRIMARY KEY (employee_id),
    FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), -- Assuming a branches table exists
    FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id)
)
CREATE TABLE financial_services.loans ( loan_id character varying(64) NOT NULL, account_id character varying(64) NOT NULL UNIQUE, loan_type character varying(50) NOT NULL, principal_amount numeric(19, 4) NOT NULL, current_principal_balance numeric(19, 4) NOT NULL, interest_rate numeric(6, 4) NOT NULL, term_months integer NOT NULL, origination_date date NOT NULL, maturity_date date NOT NULL, monthly_payment numeric(12, 4), collateral_description text, status character varying(32) NOT NULL, PRIMARY KEY (loan_id), FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id) )

[User] List all accounts having both a loan and at least one transaction in the last 7 days. Show account_id, account_type, and the total number of transactions in that period.

[Assistant]
SELECT a.account_id, a.account_type, COUNT(t.transaction_id) AS transaction_count
FROM financial_services.accounts a
INNER JOIN financial_services.loans l ON a.account_id = l.account_id
INNER JOIN financial_services.transactions t ON a.account_id = t.account_id
WHERE t.transaction_date >= NOW() - INTERVAL '7 days'
GROUP BY a.account_id, a.account_type;

[User] Add the sum of transaction amounts and the loan principal_amount in the result.

[Assistant]
SELECT a.account_id, a.account_type, COUNT(t.transaction_id) AS transaction_count, SUM(t.amount) AS total_transaction_amount, l.principal_amount
FROM financial_services.accounts a
INNER JOIN financial_services.loans l ON a.account_id = l.account_id
INNER JOIN financial_services.transactions t ON a.account_id = t.account_id
WHERE t.transaction_date >= NOW() - INTERVAL '7 days'
GROUP BY a.account_id, a.account_type, l.principal_amount;


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

[User] List all pairs of lawyers who share the same last name but have different first names. Show the first name, last name, and lawyer ID for both lawyers in each pair.

[Assistant] SELECT l1.first_name AS lawyer1_first_name, l1.last_name AS lawyer1_last_name, l1.lawyer_id AS lawyer1_id, l2.first_name AS lawyer2_first_name, l2.last_name AS lawyer2_last_name, l2.lawyer_id AS lawyer2_id FROM legal_services.lawyers AS l1 JOIN legal_services.lawyers AS l2 ON l1.last_name = l2.last_name AND l1.lawyer_id < l2.lawyer_id WHERE l1.first_name <> l2.first_name;