{"conversations": [{"role": "user", "content": "List all pairs of clients who registered on the same day, showing each client's first_name, last_name, and the registration date."}, {"role": "assistant", "content": "SELECT c1.first_name AS first_name_1, c1.last_name AS last_name_1, c2.first_name AS first_name_2, c2.last_name AS last_name_2, DATE(c1.date_registered) AS registration_date FROM legal_services.clients c1 JOIN legal_services.clients c2 ON DATE(c1.date_registered) = DATE(c2.date_registered) AND c1.client_id < c2.client_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.clients ( client_id text, first_name text, last_name text, company_name text, email text, phone text, address text, date_registered timestamp, status text )\n"}
{"conversations": [{"role": "user", "content": "Show me the number of approval-for-all events for each ERC1155 contract in the erc1155_approval_for_all table."}, {"role": "assistant", "content": "SELECT contract_address, COUNT(*) AS approval_count FROM erc1155_approval_for_all GROUP BY contract_address;"}, {"role": "user", "content": "Can you also include the number of unique wallets currently holding NFTs from each ERC1155 contract by joining with nft_holders?"}, {"role": "assistant", "content": "SELECT a.contract_address, COUNT(*) AS approval_count, COUNT(DISTINCT h.wallet_address) AS unique_holder_count FROM erc1155_approval_for_all a LEFT JOIN nft_holders h ON h.contract_address = a.contract_address AND h.contract_type = 'ERC1155' GROUP BY a.contract_address;"}, {"role": "user", "content": "Filter the results to only include contracts where the approval_count is greater than 20 and unique_holder_count is more than 5."}, {"role": "assistant", "content": "SELECT a.contract_address, COUNT(*) AS approval_count, COUNT(DISTINCT h.wallet_address) AS unique_holder_count FROM erc1155_approval_for_all a LEFT JOIN nft_holders h ON h.contract_address = a.contract_address AND h.contract_type = 'ERC1155' GROUP BY a.contract_address HAVING COUNT(*) > 20 AND COUNT(DISTINCT h.wallet_address) > 5;"}, {"role": "user", "content": "Order the results by approval_count descending and limit to the top 5 contracts."}, {"role": "assistant", "content": "SELECT a.contract_address, COUNT(*) AS approval_count, COUNT(DISTINCT h.wallet_address) AS unique_holder_count FROM erc1155_approval_for_all a LEFT JOIN nft_holders h ON h.contract_address = a.contract_address AND h.contract_type = 'ERC1155' GROUP BY a.contract_address HAVING COUNT(*) > 20 AND COUNT(DISTINCT h.wallet_address) > 5 ORDER BY approval_count DESC LIMIT 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE erc1155_approval_for_all (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction\n    transaction_index integer NOT NULL, -- Index of the transaction within the block\n    transaction_hash varchar(66) NOT NULL, -- Transaction hash\n    log_index integer NOT NULL, -- Log index\n    contract_address varchar(42) NOT NULL  -- Event contract address\n)\nCREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE nft_holder_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )\nCREATE 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 )\nCREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE token_prices_latest (\n    blockchain varchar(36) NOT NULL, -- blockchain fields for the functionType  in contract\n    address varchar(42) NOT NULL, -- address fields for the functionType  in contract\n    decimals bigint NOT NULL, -- decimals fields for the functionType  in contract\n    symbol varchar(36) NOT NULL, -- symbol fields for the functionType  in contract\n    price real NOT NULL, -- price fields for the functionType  in contract\n    timestamp timestamp(6) NOT NULL  -- timestamp fields for the functionType  in contract\n)\nCREATE TABLE erc20_approval ( block_number bigint NOT NULL, block_timestamp timestamp(6) NOT NULL, transaction_index integer NOT NULL, transaction_hash varchar NOT NULL, log_index integer NOT NULL, contract_address varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_info (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    tick varchar NOT NULL, -- Token tick\n    max_supply decimal(38,0) NOT NULL, -- Max supply\n    lim decimal(38,0) NOT NULL, -- Limit of each mint\n    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint\n    dec integer NOT NULL, -- Decimal for minimum divie\n    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)\n)\nCREATE 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 )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, log_index integer, type text, tick text, id text, amt decimal, from_address text, to_address text )\nCREATE TABLE token_activities_avalanche (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    log_index integer NOT NULL, -- Index of the log within the transaction\n    type varchar(20) NOT NULL, -- Operation: Type of event (deploy, mint, transfer, list)\n    tick varchar(255) NOT NULL, -- Ticker: Identifier of the inscription\n    id varchar(255) NOT NULL, -- Unique identifier of the inscription\n    amt decimal(38,0) NOT NULL, -- Amount to mint: States the amount of the inscription to operation. When operation is mint, has to be less or equal to \"lim\"\n    from_address varchar(42) NOT NULL, -- Address sending the inscription\n    to_address varchar(42) NOT NULL  -- Address receiving the inscription\n)\nCREATE TABLE token_balances_avalanche ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "What is the average investment value for projects that completed Series A funding rounds?"}, {"role": "assistant", "content": "SELECT AVG(investment_value) as avg_investment FROM project_fundraising_record WHERE rounds_name = 'Series A';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me all reservations with their guest IDs and room IDs where the total amount is greater than $500 and the status is 'Confirmed', ordered by check-in date."}, {"role": "assistant", "content": "SELECT reservation_id, guest_id, room_id, check_in_date, total_amount FROM hospitality_technology.reservations WHERE total_amount > 500 AND status = 'Confirmed' ORDER BY check_in_date;"}, {"role": "user", "content": "Now, join this with the service_orders table to include the total price of all services ordered for each reservation."}, {"role": "assistant", "content": "SELECT r.reservation_id, r.guest_id, r.room_id, r.check_in_date, r.total_amount, SUM(so.total_price) AS total_service_price FROM hospitality_technology.reservations r LEFT JOIN hospitality_technology.service_orders so ON r.reservation_id = so.reservation_id WHERE r.total_amount > 500 AND r.status = 'Confirmed' GROUP BY r.reservation_id, r.guest_id, r.room_id, r.check_in_date, r.total_amount ORDER BY r.check_in_date;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.reservations ( reservation_id.text, property_id.text, guest_id.text, room_id.text, room_type_id.text, check_in_date.date, check_out_date.date, actual_check_in_ts.timestamp, actual_check_out_ts.timestamp, num_adults.integer, num_children.integer, status.text, booking_source.text, rate_plan_id.text, total_amount.numeric, amount_paid.numeric, special_requests.text, created_at.timestamp, updated_at.timestamp )\nCREATE TABLE hospitality_technology.service_orders ( order_id character varying(64) NOT NULL, reservation_id character varying(64), guest_id character varying(64) NOT NULL, service_id character varying(64) NOT NULL, staff_id_ordered character varying(64), staff_id_delivered character varying(64), order_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, delivery_timestamp timestamp with time zone, quantity integer NOT NULL DEFAULT 1, unit_price numeric(10, 2) NOT NULL, total_price numeric(12, 2) NOT NULL, status character varying(50) NOT NULL, notes text, bill_id character varying(64), PRIMARY KEY (order_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (service_id) REFERENCES hospitality_technology.services(service_id), FOREIGN KEY (staff_id_ordered) REFERENCES hospitality_technology.staff(staff_id), FOREIGN KEY (staff_id_delivered) REFERENCES hospitality_technology.staff(staff_id) )\nCREATE TABLE hospitality_technology.reviews ( review_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, reservation_id character varying(64) UNIQUE, guest_id character varying(64) NOT NULL, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source character varying(100), review_date timestamp with time zone NOT NULL DEFAULT current_timestamp, is_public boolean DEFAULT true, staff_response text, response_staff_id character varying(64), response_date timestamp with time zone, PRIMARY KEY (review_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (response_staff_id) REFERENCES hospitality_technology.staff(staff_id) )\n"}
{"conversations": [{"role": "user", "content": "Now, sort the results by the date opened, oldest first, and show only the top 10."}, {"role": "assistant", "content": "SELECT case_name, case_number, date_opened FROM legal_services.cases WHERE lead_lawyer_id = 'lawyer_abc' AND status = 'Open' AND case_type = 'Criminal' ORDER BY date_opened ASC LIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.cases ( case_id.text, case_number.text, case_name.text, client_id.text, lead_lawyer_id.text, case_type.text, status.text, date_opened.timestamp, date_closed.timestamp, description.text, court_jurisdiction.text )\n"}
{"conversations": [{"role": "user", "content": "For each vehicle, find the vehicle in the same depot that was acquired immediately before it. Display the current vehicle_id, acquisition_date, previous vehicle_id, and its acquisition_date."}, {"role": "assistant", "content": "SELECT v.vehicle_id, v.acquisition_date, prev.vehicle_id AS previous_vehicle_id, prev.acquisition_date AS previous_acquisition_date FROM transportation.vehicles v JOIN transportation.vehicles prev ON v.depot_id = prev.depot_id AND prev.acquisition_date = (SELECT MAX(acquisition_date) FROM transportation.vehicles WHERE depot_id = v.depot_id AND acquisition_date < v.acquisition_date);"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all claims along with the first and last names of the agent who is currently handling each claim."}, {"role": "assistant", "content": "SELECT c.claim_id, c.policy_id, c.incident_date, a.first_name AS agent_first_name, a.last_name AS agent_last_name\nFROM insurance.claims c\nJOIN insurance.agents a ON c.claim_handler_id = a.agent_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.claims (\n    claim_id character varying(64) NOT NULL, -- unique identifier for the claim\n    policy_id character varying(64) NOT NULL, -- identifier of the policy under which the claim is made (FK to policies)\n    customer_id character varying(64) NOT NULL, -- identifier of the customer making the claim (FK to customers)\n    incident_date timestamp NOT NULL, -- date and time of the incident leading to the claim\n    reported_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the claim was reported\n    description text NOT NULL, -- detailed description of the incident and claim\n    estimated_loss numeric(15, 2), -- initial estimated cost of the loss\n    status character varying(30) NOT NULL, -- e.g., Filed, Processing, Under Review, Approved, Denied, Settled\n    settlement_amount numeric(15, 2), -- final amount paid out\n    settlement_date date,\n    claim_handler_id character varying(64), -- identifier for the employee handling the claim (FK to employees/adjusters)\n    police_report_number character varying(100),\n    PRIMARY KEY (claim_id)\n)\nCREATE TABLE insurance.agents ( agent_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, agency_name character varying(150), license_number character varying(100) NOT NULL UNIQUE, license_state character varying(50) NOT NULL, contact_email character varying(128) UNIQUE, contact_phone character varying(30), hire_date date, termination_date date, status character varying(20) NOT NULL DEFAULT 'Active', commission_rate numeric(5, 4) NOT NULL DEFAULT 0.05, manager_id character varying(64), PRIMARY KEY (agent_id) )\n"}
{"conversations": [{"role": "user", "content": "List all users who have received any notification, showing their username and the total number of notifications they received. Assume a users table with user_id and username exists."}, {"role": "assistant", "content": "SELECT u.username, COUNT(n.notification_id) FROM users u JOIN notifications n ON u.user_id = n.user_id GROUP BY u.username"}, {"role": "user", "content": "Filter this to only include users who have received notifications that were sent before '2023-11-01', showing the same details."}, {"role": "assistant", "content": "SELECT u.username, COUNT(n.notification_id) FROM users u JOIN notifications n ON u.user_id = n.user_id WHERE n.sent_at < '2023-11-01' GROUP BY u.username"}, {"role": "user", "content": "For users who received notifications before '2023-11-01', show their username and the latest timestamp of a notification they received within that period."}, {"role": "assistant", "content": "SELECT u.username, MAX(n.sent_at) FROM users u JOIN notifications n ON u.user_id = n.user_id WHERE n.sent_at < '2023-11-01' GROUP BY u.username"}], "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. \n##Table Structure\nCREATE TABLE trading_platform.utxos ( utxo_id text PRIMARY KEY, transaction_id text, output_index int, address text, amount numeric, spent boolean )\nCREATE TABLE trading_platform.dapps ( dapp_id text PRIMARY KEY, name text, description text, url text )\nCREATE TABLE trading_platform.peers ( peer_id text PRIMARY KEY, ip_address text, port int, last_seen timestamp )\nCREATE TABLE trading_platform.metadata ( metadata_id text PRIMARY KEY, asset_id text, key text, value text )\nCREATE TABLE trading_platform.notifications ( notification_id text PRIMARY KEY, user_id text, message text, sent_at timestamp, read_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Calculate the total quantity traded for each asset, showing the asset name and symbol."}, {"role": "assistant", "content": "SELECT T1.name, T1.symbol, SUM(T2.quantity) FROM trading_platform.assets AS T1 JOIN trading_platform.trades AS T2 ON T1.asset_id = T2.asset_id GROUP BY 1, 2;"}, {"role": "user", "content": "Only show assets where the total quantity traded is more than 5000."}, {"role": "assistant", "content": "SELECT T1.name, T1.symbol, SUM(T2.quantity) FROM trading_platform.assets AS T1 JOIN trading_platform.trades AS T2 ON T1.asset_id = T2.asset_id GROUP BY 1, 2 HAVING SUM(T2.quantity) > 5000;"}, {"role": "user", "content": "Actually, instead of total quantity, show the average trade price for each asset."}, {"role": "assistant", "content": "SELECT T1.name, T1.symbol, AVG(T2.price) FROM trading_platform.assets AS T1 JOIN trading_platform.trades AS T2 ON T1.asset_id = T2.asset_id GROUP BY 1, 2;"}, {"role": "user", "content": "Sort those assets by the average price in descending order."}, {"role": "assistant", "content": "SELECT T1.name, T1.symbol, AVG(T2.price) FROM trading_platform.assets AS T1 JOIN trading_platform.trades AS T2 ON T1.asset_id = T2.asset_id GROUP BY 1, 2 ORDER BY AVG(T2.price) DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.users ( user_id.text, username.text, email.text, password_hash.text, created_at.timestamp )\nCREATE TABLE trading_platform.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )\nCREATE TABLE trading_platform.orders ( order_id text, user_id text, wallet_id text, asset_id text, order_type text, quantity numeric, price numeric, status text, created_at timestamp )\nCREATE TABLE trading_platform.trades ( trade_id character varying(64) NOT NULL, order_id character varying(64) NOT NULL, buyer_id character varying(64) NOT NULL, seller_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, quantity numeric(38,14) NOT NULL, price numeric(38,14) NOT NULL, traded_at timestamp NOT NULL, PRIMARY KEY (trade_id) )\nCREATE TABLE trading_platform.assets ( asset_id text, name text, symbol text, type text )\nCREATE TABLE trading_platform.dapps ( dapp_id text, name text, description text, url text )\nCREATE TABLE trading_platform.peers ( peer_id.text, ip_address.text, port.integer, last_seen.timestamp )\nCREATE TABLE trading_platform.metadata ( metadata_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, key character varying(128) NOT NULL, value text NOT NULL, PRIMARY KEY (metadata_id) )\nCREATE TABLE trading_platform.kyc_audit ( kyc_audit_id.text, user_id.text, status.text, reviewed_at.timestamp )\nCREATE TABLE trading_platform.logs ( log_id text PRIMARY KEY, user_id text, action text, details text, logged_at timestamp )\nCREATE TABLE trading_platform.notifications ( notification_id text, user_id text, message text, sent_at timestamp, read_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "What is the total USD value held by all centralized exchanges (CEX) for the token with the symbol 'BTC'?"}, {"role": "assistant", "content": "SELECT SUM(usd_value) AS total_btc_cex_value FROM cex_token_balance WHERE token_symbol = 'BTC';"}, {"role": "user", "content": "Can you break down the total USD value for 'BTC' held by CEXes by chain?"}, {"role": "assistant", "content": "SELECT chain, SUM(usd_value) AS total_btc_cex_value FROM cex_token_balance WHERE token_symbol = 'BTC' GROUP BY chain ORDER BY total_btc_cex_value DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE project_fundraising_record ( id character varying(32) NOT NULL,  -- fundraising record id project_id character varying(32) NOT NULL, -- the invested project's id project_name character varying(128) NOT NULL, -- name of the invested project rounds_name character varying(32), -- name of the fundraising round investment_value numeric(38,14), -- amount of the fundraising in USD investment_date character varying(128), -- the date of the investment happened introduction character varying(128), -- the introduction of the invested project valuation numeric(38,14), -- the valuation of the project in USD when invested )\nCREATE 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) )\nCREATE 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 )\nCREATE 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) )\nCREATE TABLE smart_money_profit ( address text, rank numeric, profit numeric, roi numeric, realized_ratio numeric, most_profit_token text, last_trade_time text, chain text )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me wallet addresses that hold more than 1000 of any ERC20 token, along with the token symbol and amount, sorted by amount in descending order."}, {"role": "assistant", "content": "SELECT b.wallet_address, t.symbol, b.amount FROM erc20_balances b JOIN sui_coins_metadata t ON b.contract_address = t.coin_type WHERE CAST(b.amount AS decimal) > 1000 ORDER BY CAST(b.amount AS decimal) DESC;"}, {"role": "user", "content": "Can you also include the current price of each token from the token_prices_latest table?"}, {"role": "assistant", "content": "SELECT b.wallet_address, t.symbol, b.amount, p.price FROM erc20_balances b JOIN sui_coins_metadata t ON b.contract_address = t.coin_type JOIN token_prices_latest p ON b.contract_address = p.address WHERE CAST(b.amount AS decimal) > 1000 ORDER BY CAST(b.amount AS decimal) DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE erc1155_approval_for_all (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction\n    transaction_index integer NOT NULL, -- Index of the transaction within the block\n    transaction_hash varchar(66) NOT NULL, -- Transaction hash\n    log_index integer NOT NULL, -- Log index\n    contract_address varchar(42) NOT NULL  -- Event contract address\n)\nCREATE TABLE erc20_balances ( block_number.bigint, contract_address.text, wallet_address.text, amount.text, pk.text )\nCREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_holders ( block_number bigint, contract_address varchar, wallet_address varchar, token_id varchar, contract_type varchar, amount varchar, pk varchar )\nCREATE TABLE sui_coins_metadata ( object_id varchar, coin_type varchar, status varchar, decimals bigint, description varchar, icon_url varchar, symbol varchar, name varchar )\nCREATE TABLE nft_metadata (\n    blockchain varchar NOT NULL, -- blockchain fields for the functionType  in contract\n    contract_address varchar NOT NULL, -- Contract address(with bloom filter)\n    token_id varchar NOT NULL, -- The number of the token\n    contract_name varchar NOT NULL, -- contract_name fields for the functionType  in contract\n    erc_type varchar NOT NULL, -- The type of token\n    amount bigint NOT NULL, -- amount fields for the functionType  in contract\n    minter varchar NOT NULL, -- minter fields for the functionType  in contract\n    owner varchar NOT NULL, -- owner fields for the functionType  in contract\n    mint_block_number bigint NOT NULL, -- mint_block_number fields for the functionType  in contract\n    mint_time bigint NOT NULL, -- mint_time fields for the functionType  in contract\n    mint_transaction_hash varchar NOT NULL, -- mint_transaction_hash fields for the functionType  in contract\n    mint_price varchar NOT NULL, -- mint_price fields for the functionType  in contract\n    token_uri varchar NOT NULL, -- token_uri fields for the functionType  in contract\n    metadata varchar NOT NULL, -- metadata fields for the functionType  in contract\n    name varchar NOT NULL, -- name fields for the functionType  in contract\n    image_uri varchar NOT NULL, -- image_uri fields for the functionType  in contract\n    traits varchar NOT NULL, -- traits fields for the functionType  in contract\n    updated_at bigint NOT NULL, -- updated_at fields for the functionType  in contract\n    status varchar NOT NULL, -- status fields for the functionType  in contract\n    rarity_score real NOT NULL, -- rarity_score fields for the functionType  in contract\n    rarity_rank integer NOT NULL, -- rarity_rank fields for the functionType  in contract\n    unique_attribute_count integer NOT NULL, -- unique_attribute_count fields for the functionType  in contract\n    pk integer NOT NULL  -- Partition key for the table(floor(mint_time / 1000 / 86400 / 30))\n)\nCREATE TABLE token_prices_latest ( blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE token_info ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL )\nCREATE TABLE mud_holesky_redstone (\n    address varchar NOT NULL, -- address fields for the functionType  in contract\n    table_id varchar NOT NULL, -- table_id fields for the functionType  in contract\n    key_bytes varchar NOT NULL, -- key_bytes fields for the functionType  in contract\n    key0 varchar NOT NULL, -- key0 fields for the functionType  in contract\n    key1 varchar NOT NULL, -- key1 fields for the functionType  in contract\n    static_data varchar NOT NULL, -- static_data fields for the functionType  in contract\n    encoded_lengths varchar NOT NULL, -- encoded_lengths fields for the functionType  in contract\n    dynamic_data varchar NOT NULL, -- dynamic_data fields for the functionType  in contract\n    is_deleted boolean NOT NULL, -- is_deleted fields for the functionType  in contract\n    block_number bigint NOT NULL, -- Block number uniquely identifying the block\n    log_index bigint NOT NULL  -- Index of the log within the transaction\n)\nCREATE 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 )\nCREATE TABLE token_balances_avalanche (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar(20) NOT NULL, -- Ticker: Identifier of the inscription\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply decimal(38,0) NOT NULL, -- Max supply: Set max supply of the inscription\n    amount decimal(38,0) NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "For each Bitcoin token tick, show me the creator address from the token_info_bitcoin table and the number of unique wallets currently holding that token."}, {"role": "assistant", "content": "SELECT ti.tick, ti.creator, COUNT(DISTINCT tb.wallet_address) AS unique_wallets FROM token_info_bitcoin ti JOIN token_balances_bitcoin tb ON ti.tick = tb.tick GROUP BY ti.tick, ti.creator;"}, {"role": "user", "content": "Now, only include ticks where there are more than 5 unique wallets, and order the result by the number of unique wallets descending."}, {"role": "assistant", "content": "SELECT ti.tick, ti.creator, COUNT(DISTINCT tb.wallet_address) AS unique_wallets FROM token_info_bitcoin ti JOIN token_balances_bitcoin tb ON ti.tick = tb.tick GROUP BY ti.tick, ti.creator HAVING COUNT(DISTINCT tb.wallet_address) > 5 ORDER BY unique_wallets DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE erc1155_approval_for_all (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction\n    transaction_index integer NOT NULL, -- Index of the transaction within the block\n    transaction_hash varchar(66) NOT NULL, -- Transaction hash\n    log_index integer NOT NULL, -- Log index\n    contract_address varchar(42) NOT NULL  -- Event contract address\n)\nCREATE TABLE erc20_balances ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk varchar )\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address text, wallet_address text, amount text, pk integer )\nCREATE TABLE nft_holders ( block_number.bigint, contract_address.text, wallet_address.text, token_id.text, contract_type.text, amount.text, pk.text )\nCREATE TABLE sui_coins ( object_id varchar NOT NULL, status varchar NOT NULL, coin_type varchar NOT NULL, balance varchar NOT NULL, owner varchar NOT NULL )\nCREATE TABLE sui_coins_metadata (\n    object_id varchar NOT NULL, -- object id of the coin metadata object\n    coin_type varchar NOT NULL, -- coin type, eg. 0x...66::reap_token::REAP_TOKEN\n    status varchar NOT NULL, -- coin status, eg. exists, deleted\n    decimals bigint NOT NULL, -- decimals of the coin\n    description varchar NOT NULL, -- description of the coin\n    icon_url varchar NOT NULL, -- icon url of the coin\n    symbol varchar NOT NULL, -- symbol of the coin\n    name varchar NOT NULL  -- name of the coin\n)\nCREATE TABLE sui_nfts ( object_id.text, status.text, collection_type.text, package_id.text, previous_transaction.text, display.text, owner.text, name.text )\nCREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_prices ( uuid.text, blockchain.text, address.text, decimals.bigint, symbol.text, price.real, timestamp.timestamp )\nCREATE TABLE token_prices_latest ( blockchain.text, address.text, decimals.bigint, symbol.text, price.real, timestamp.timestamp )\nCREATE TABLE erc20_approval ( block_number.bigint, block_timestamp.timestamp, transaction_index.integer, transaction_hash.text, log_index.integer, contract_address.text, pk.integer )\nCREATE TABLE token_balances (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar NOT NULL, -- Token tick\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply decimal(38,0) NOT NULL, -- Max supply\n    amount decimal(38,0) NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE TABLE token_info ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL )\nCREATE 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 )\nCREATE TABLE mud_holesky_redstone ( address text, table_id text, key_bytes text, key0 text, key1 text, static_data text, encoded_lengths text, dynamic_data text, is_deleted boolean, block_number bigint, log_index bigint )\nCREATE TABLE token_balances_bitcoin (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar(255) NOT NULL, -- Ticker: Identifier of the inscription\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply varchar NOT NULL, -- Max supply: Set max supply of the inscription\n    amount varchar NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE 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 )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, log_index integer, type text, tick text, id text, amt decimal, from_address text, to_address text )\nCREATE 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 )\nCREATE TABLE token_balances_avalanche (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar(20) NOT NULL, -- Ticker: Identifier of the inscription\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply decimal(38,0) NOT NULL, -- Max supply: Set max supply of the inscription\n    amount decimal(38,0) NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all tokens with a price below $1 and a 24-hour trading volume over $10 million."}, {"role": "assistant", "content": "SELECT token_name, token_symbol, price, total_volume FROM token_basic_info WHERE price < 1 AND CAST(total_volume AS double precision) > 10000000;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE token_basic_info ( coin_id character varying(100) NOT NULL, token_name character varying(100) NOT NULL, token_symbol character varying(100) NOT NULL, token_address character varying(100) NOT NULL, chain text, price double precision, price_change_percentage_1h double precision, price_change_percentage_24h double precision, price_change_percentage_7d double precision, highest_price_24h double precision, lowest_price_24h double precision, market_cap double precision, market_cap_rank bigint, market_cap_change_percentage_24h text, total_volume text, narrative text, trend_rank bigint )\n"}
{"conversations": [{"role": "user", "content": "For each patient, show the total number of diagnoses they have received, along with their patient ID and the ID of their latest diagnosis. Join with the diagnoses table."}, {"role": "assistant", "content": "SELECT patient_id, COUNT(diagnosis_id) AS diagnosis_count, MAX(diagnosis_id) AS latest_diagnosis_id\nFROM healthcare.diagnoses\nGROUP BY patient_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.appointments ( appointment_id text, patient_id text, doctor_id text, appointment_time timestamp, duration_minutes integer, reason text, status text, location_id text, notes text, created_at timestamp )\nCREATE TABLE healthcare.medical_records ( record_id text, patient_id text, appointment_id text, doctor_id text, record_date timestamp, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals text, created_at timestamp )\nCREATE TABLE healthcare.diagnoses ( diagnosis_id text, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )\nCREATE TABLE healthcare.medications ( medication_id text, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )\nCREATE TABLE healthcare.prescriptions ( prescription_id text, record_id text, patient_id text, doctor_id text, medication_id text, dosage text, frequency text, route text, start_date date, end_date date, quantity_dispensed numeric, refills_allowed integer, prescription_date timestamp )\nCREATE TABLE healthcare.insurance_plans ( plan_id text, plan_name text, insurance_provider text, plan_type text, contact_phone text, website text )\nCREATE TABLE healthcare.patient_insurance ( patient_insurance_id text, patient_id text, plan_id text, policy_number text, group_number text, subscriber_name text, effective_date date, expiration_date date, is_primary boolean )\n"}
{"conversations": [{"role": "user", "content": "Can you help me fetch the inventory details for components associated with a specific aircraft build, including the batch number, quantity, and warehouse location?"}, {"role": "assistant", "content": "MATCH (ab:AircraftBuild {build_id: 'specific_build_id'})-[:IS_MODEL]->(am:AircraftModel),\n(ib:InventoryBatch)-[:IS_INSTANCE_OF]->(c:Component)\nRETURN ib.inventory_record_id, ib.batch_number, ib.quantity, ib.location_warehouse"}, {"role": "user", "content": "Can you modify this to show only inventory batches received after a specific date, say June 1, 2023?"}, {"role": "assistant", "content": "MATCH (ab:AircraftBuild {build_id: 'specific_build_id'})-[:IS_MODEL]->(am:AircraftModel),\n(ib:InventoryBatch)-[:IS_INSTANCE_OF]->(c:Component)\nWHERE ib.received_date > datetime('2023-06-01')\nRETURN ib.inventory_record_id, ib.batch_number, ib.quantity, ib.location_warehouse"}, {"role": "user", "content": "What if I also want to exclude batches with quantities less than 10?"}, {"role": "assistant", "content": "MATCH (ab:AircraftBuild {build_id: 'specific_build_id'})-[:IS_MODEL]->(am:AircraftModel),\n(ib:InventoryBatch)-[:IS_INSTANCE_OF]->(c:Component)\nWHERE ib.received_date > datetime('2023-06-01') AND ib.quantity >= 10\nRETURN ib.inventory_record_id, ib.batch_number, ib.quantity, ib.location_warehouse"}], "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. \n##Table Structure\nNode Label ':AircraftModel'. Properties: { model_id: String (Constraint: UNIQUE), model_name: String, manufacturer: String, passenger_capacity: Integer, max_range_km: Integer, engine_type: String, wingspan_m: Float, status: String, first_flight_date: Date }. Index on model_id.\nNode Label ':Material'. Properties: { material_id: String (Constraint: UNIQUE), material_name: String, specification: String, description: String, density_kg_m3: Float, tensile_strength_mpa: Integer }. Index on material_id.\nNode Label ':AssemblyLine'. Properties: { line_id: String (Constraint: UNIQUE), line_name: String, location_building: String, location_area: String, capacity_units_per_month: Integer, status: String }. Relationship: (:AssemblyLine)-[:BUILDS_MODEL]->(:AircraftModel {model_id}). Index on line_id.\nNode Label ':AssemblyStep'. Properties: { step_id: String (Constraint: UNIQUE), step_number: Integer, step_name: String, description: String, standard_duration_hours: Float, required_skill_level: String, workstation: String }. Relationship: (:AssemblyLine {line_id})-[:HAS_STEP {sequence: <step_number>}]->(:AssemblyStep). Index on step_id.\nNode Label ':AircraftBuild'. Properties: { build_id: String (Constraint: UNIQUE), serial_number: String (Constraint: UNIQUE), build_start_date: Datetime, estimated_completion_date: Date, actual_completion_date: Datetime, current_status: String, customer_order_id: String }. Relationships: (:AircraftBuild)-[:IS_MODEL]->(:AircraftModel {model_id}), (:AircraftBuild)-[:ASSEMBLED_ON]->(:AssemblyLine {line_id}). Index on build_id, serial_number, current_status.\nNode Label ':Employee'. Properties: { employee_id: String (Constraint: UNIQUE), first_name: String, last_name: String, job_title: String, skill_certifications: String[], hire_date: Date, employment_status: String }. Relationships: (:Employee)-[:ASSIGNED_TO]->(:AssemblyLine {line_id}), (:Employee)-[:REPORTS_TO]->(:Employee {employee_id as supervisor_id}). Index on employee_id.\nNode Label ':InventoryBatch'. Properties: { inventory_record_id: String (Constraint: UNIQUE), quantity: Integer, location_warehouse: String, location_bin: String, received_date: Datetime, expiry_date: Date, batch_number: String, last_updated: Datetime }. Relationship: (:InventoryBatch)-[:IS_INSTANCE_OF]->(:Component {component_id}). Index on inventory_record_id, component_id.\n"}
{"conversations": [{"role": "user", "content": "For each user, show their username and the timestamp of their most recent notification. Include users who have never received notifications."}, {"role": "assistant", "content": "SELECT T1.username, max(T2.sent_at) FROM users AS T1 LEFT JOIN trading_platform.notifications AS T2 ON T1.user_id = T2.user_id GROUP BY T1.username"}, {"role": "user", "content": "Could you also include the total number of notifications for each user?"}, {"role": "assistant", "content": "SELECT T1.username, count(T2.notification_id), max(T2.sent_at) FROM users AS T1 LEFT JOIN trading_platform.notifications AS T2 ON T1.user_id = T2.user_id GROUP BY T1.username"}, {"role": "user", "content": "Actually, only show users whose latest notification is unread."}, {"role": "assistant", "content": "WITH LatestNotification AS ( SELECT user_id, sent_at, read_at, ROW_NUMBER() OVER(PARTITION BY user_id ORDER BY sent_at DESC) AS rn FROM trading_platform.notifications ) SELECT T1.username, T2.sent_at FROM users AS T1 JOIN LatestNotification AS T2 ON T1.user_id = T2.user_id WHERE T2.rn = 1 AND T2.read_at IS NULL"}, {"role": "user", "content": "Also, include the count of unread notifications for these users."}, {"role": "assistant", "content": "WITH LatestNotification AS ( SELECT user_id, sent_at, read_at, ROW_NUMBER() OVER(PARTITION BY user_id ORDER BY sent_at DESC) AS rn FROM trading_platform.notifications ) SELECT T1.username, count(CASE WHEN T3.read_at IS NULL THEN T3.notification_id ELSE NULL END), T2.sent_at FROM users AS T1 JOIN LatestNotification AS T2 ON T1.user_id = T2.user_id AND T2.rn = 1 AND T2.read_at IS NULL JOIN trading_platform.notifications AS T3 ON T1.user_id = T3.user_id GROUP BY T1.username, T2.sent_at"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.notifications ( notification_id.text, user_id.text, message.text, sent_at.timestamp, read_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "List all wallet addresses that hold SUI coins with a balance greater than 1,000,000. Please show the coin_type as well."}, {"role": "assistant", "content": "SELECT owner, coin_type, balance\nFROM sui_coins\nWHERE CAST(balance AS DECIMAL) > 1000000;"}, {"role": "user", "content": "Please add the coin symbol and name by joining with sui_coins_metadata, and only show coins that have 'Utility' in their description."}, {"role": "assistant", "content": "SELECT sc.owner, sc.coin_type, sc.balance, scm.symbol, scm.name\nFROM sui_coins sc\nJOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type\nWHERE CAST(sc.balance AS DECIMAL) > 1000000 AND scm.description LIKE '%Utility%';"}, {"role": "user", "content": "Show only coins with status 'active' and limit results to 10, sorted by balance descending."}, {"role": "assistant", "content": "SELECT sc.owner, sc.coin_type, sc.balance, scm.symbol, scm.name\nFROM sui_coins sc\nJOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type\nWHERE CAST(sc.balance AS DECIMAL) > 1000000 AND scm.description LIKE '%Utility%' AND sc.status = 'active'\nORDER BY CAST(sc.balance AS DECIMAL) DESC\nLIMIT 10;"}, {"role": "user", "content": "Please add the coin description in the result as well."}, {"role": "assistant", "content": "SELECT sc.owner, sc.coin_type, sc.balance, scm.symbol, scm.name, scm.description\nFROM sui_coins sc\nJOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type\nWHERE CAST(sc.balance AS DECIMAL) > 1000000 AND scm.description LIKE '%Utility%' AND sc.status = 'active'\nORDER BY CAST(sc.balance AS DECIMAL) DESC\nLIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE erc20_balances ( block_number bigint, contract_address text, wallet_address text, amount text, pk text )\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address text, wallet_address text, amount text, pk integer )\nCREATE TABLE nft_holders ( block_number bigint, contract_address text, wallet_address text, token_id text, contract_type text, amount text, pk text )\nCREATE TABLE nft_holder_historical ( block_number bigint, contract_address text, wallet_address text, token_id text, contract_type text, amount text, pk integer )\nCREATE TABLE sui_coins ( object_id text, status text, coin_type text, balance text, owner text )\nCREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE token_prices_latest ( blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash text, log_index integer, contract_address text, pk integer )\nCREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\nCREATE TABLE token_info ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, tick text, max_supply decimal, lim decimal, wlim decimal, dec integer, creator text )\nCREATE 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 )\nCREATE TABLE mud_holesky_redstone ( address text, table_id text, key_bytes text, key0 text, key1 text, static_data text, encoded_lengths text, dynamic_data text, is_deleted boolean, block_number bigint, log_index bigint )\nCREATE TABLE token_balances_bitcoin ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply text, amount text )\nCREATE 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 )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, log_index integer, type text, tick text, id text, amt decimal, from_address text, to_address text )\nCREATE 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 )\nCREATE TABLE token_balances_avalanche ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "What is the detailed repair history of the equipment used by the staff with staff_id 'STAFF123' during maintenance tasks?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information on the detailed repair history of equipment used by staff members. The data in the maintenance_records table only includes information about maintenance tasks, such as record_id, asset_id, maintenance type, and staff_id, but does not cover equipment repair histories."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.maintenance_records ( record_id.text, asset_id.text, asset_type.text, maintenance_type.text, staff_id.text, start_datetime.timestamp, end_datetime.timestamp, description.text, cost.numeric, status.text )\n"}
{"conversations": [{"role": "user", "content": "What is the ticket price for a journey on train number T4321?"}, {"role": "assistant", "content": "I'm sorry, but I don't have access to information about ticket prices for specific trains. The data I have is limited to train details such as model, manufacturer, capacity, and maintenance schedules. For ticket pricing, please consult the ticketing office or the official website."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.trains ( train_id text PRIMARY KEY, train_number text UNIQUE, model text, manufacturer text, year_manufactured int, capacity int, status text, last_maintenance_date date, next_maintenance_date date )\n"}
{"conversations": [{"role": "user", "content": "Provide a summary for each user, showing their associated KYC status and the total number of UTXOs connected to them."}, {"role": "assistant", "content": "SELECT kyc.user_id, kyc.status, COUNT(u.utxo_id) AS utxo_count FROM trading_platform.kyc_audit kyc JOIN trading_platform.utxos u ON kyc.user_id = u.user_id GROUP BY kyc.user_id, kyc.status;"}, {"role": "user", "content": "Could you filter the summary to include only users whose status is 'pending' or 'rejected'?"}, {"role": "assistant", "content": "SELECT kyc.user_id, kyc.status, COUNT(u.utxo_id) AS utxo_count FROM trading_platform.kyc_audit kyc JOIN trading_platform.utxos u ON kyc.user_id = u.user_id WHERE kyc.status IN ('pending', 'rejected') GROUP BY kyc.user_id, kyc.status;"}, {"role": "user", "content": "Also, limit the results to users with a count of more than 5 UTXOs."}, {"role": "assistant", "content": "SELECT kyc.user_id, kyc.status, COUNT(u.utxo_id) AS utxo_count FROM trading_platform.kyc_audit kyc JOIN trading_platform.utxos u ON kyc.user_id = u.user_id WHERE kyc.status IN ('pending', 'rejected') GROUP BY kyc.user_id, kyc.status HAVING COUNT(u.utxo_id) > 5;"}, {"role": "user", "content": "Present the final list ordered by the UTXO count in descending order."}, {"role": "assistant", "content": "SELECT kyc.user_id, kyc.status, COUNT(u.utxo_id) AS utxo_count FROM trading_platform.kyc_audit kyc JOIN trading_platform.utxos u ON kyc.user_id = u.user_id WHERE kyc.status IN ('pending', 'rejected') GROUP BY kyc.user_id, kyc.status HAVING COUNT(u.utxo_id) > 5 ORDER BY utxo_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )\nCREATE TABLE trading_platform.kyc_audit ( kyc_audit_id.text, user_id.text, status.text, reviewed_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "For each prescription, find the next prescription for the same patient. Return current prescription_id, next_prescription_id, patient_id, and days between start dates."}, {"role": "assistant", "content": "SELECT p1.patient_id,\n       p1.prescription_id AS current_id,\n       p2.prescription_id AS next_id,\n       (p2.start_date - p1.start_date) AS days_between\nFROM healthcare.prescriptions p1\nJOIN healthcare.prescriptions p2\n  ON p1.patient_id = p2.patient_id\n AND p2.start_date = (\n       SELECT MIN(start_date)\n       FROM healthcare.prescriptions p3\n       WHERE p3.patient_id = p1.patient_id\n         AND p3.start_date > p1.start_date\n   );"}, {"role": "user", "content": "Only include pairs where days_between is less than 30 days."}, {"role": "assistant", "content": "SELECT p1.patient_id,\n       p1.prescription_id AS current_id,\n       p2.prescription_id AS next_id,\n       (p2.start_date - p1.start_date) AS days_between\nFROM healthcare.prescriptions p1\nJOIN healthcare.prescriptions p2\n  ON p1.patient_id = p2.patient_id\n AND p2.start_date = (\n       SELECT MIN(start_date)\n       FROM healthcare.prescriptions p3\n       WHERE p3.patient_id = p1.patient_id\n         AND p3.start_date > p1.start_date\n   )\nWHERE (p2.start_date - p1.start_date) < 30;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.prescriptions ( prescription_id.text, record_id.text, patient_id.text, doctor_id.text, medication_id.text, dosage.text, frequency.text, route.text, start_date.date, end_date.date, quantity_dispensed.numeric, refills_allowed.integer, prescription_date.timestamp )\n"}
{"conversations": [{"role": "user", "content": "I need to check the inventory status of components, including their batch details and warehouse location."}, {"role": "assistant", "content": "MATCH (i:InventoryBatch)-[:IS_INSTANCE_OF]->(c:Component)\nRETURN c.component_id, c.component_name, i.inventory_record_id, i.quantity, i.location_warehouse, i.location_bin, i.received_date, i.batch_number"}, {"role": "user", "content": "Can you filter this to show only batches with a quantity less than 50?"}, {"role": "assistant", "content": "MATCH (i:InventoryBatch)-[:IS_INSTANCE_OF]->(c:Component)\nWHERE i.quantity < 50\nRETURN c.component_id, c.component_name, i.inventory_record_id, i.quantity, i.location_warehouse, i.location_bin, i.received_date, i.batch_number"}, {"role": "user", "content": "What if I want to exclude batches with an expiry date before 2024?"}, {"role": "assistant", "content": "MATCH (i:InventoryBatch)-[:IS_INSTANCE_OF]->(c:Component)\nWHERE i.quantity < 50 AND i.expiry_date >= date('2024-01-01')\nRETURN c.component_id, c.component_name, i.inventory_record_id, i.quantity, i.location_warehouse, i.location_bin, i.received_date, i.batch_number"}, {"role": "user", "content": "Can you order the results by received date in descending order?"}, {"role": "assistant", "content": "MATCH (i:InventoryBatch)-[:IS_INSTANCE_OF]->(c:Component)\nWHERE i.quantity < 50 AND i.expiry_date >= date('2024-01-01')\nRETURN c.component_id, c.component_name, i.inventory_record_id, i.quantity, i.location_warehouse, i.location_bin, i.received_date, i.batch_number\nORDER BY i.received_date DESC"}], "system": "You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement. \n##Table Structure\nNode Label ':Component'. Properties: { component_id: String (Constraint: UNIQUE), part_number: String (Constraint: UNIQUE), component_name: String, description: String, weight_kg: Float, cost_usd: Float, criticality_level: String }. Relationships: (:Component)-[:MADE_OF]->(:Material {material_id}), (:Component)-[:SUPPLIED_BY]->(:Supplier {supplier_id}). Index on component_id, part_number.\nNode Label ':Supplier'. Properties: { supplier_id: String (Constraint: UNIQUE), supplier_name: String, address: String, country: String, contact_person: String, contact_email: String, quality_rating: Float, certified_date: Date }. Index on supplier_id.\nNode Label ':Material'. Properties: { material_id: String (Constraint: UNIQUE), material_name: String, specification: String, description: String, density_kg_m3: Float, tensile_strength_mpa: Integer }. Index on material_id.\nNode Label ':AssemblyLine'. Properties: { line_id: String (Constraint: UNIQUE), line_name: String, location_building: String, location_area: String, capacity_units_per_month: Integer, status: String }. Relationship: (:AssemblyLine)-[:BUILDS_MODEL]->(:AircraftModel {model_id}). Index on line_id.\nNode Label ':AssemblyStep'. Properties: { step_id: String (Constraint: UNIQUE), step_number: Integer, step_name: String, description: String, standard_duration_hours: Float, required_skill_level: String, workstation: String }. Relationship: (:AssemblyLine {line_id})-[:HAS_STEP {sequence: <step_number>}]->(:AssemblyStep). Index on step_id.\nNode Label ':AircraftBuild'. Properties: { build_id: String (Constraint: UNIQUE), serial_number: String (Constraint: UNIQUE), build_start_date: Datetime, estimated_completion_date: Date, actual_completion_date: Datetime, current_status: String, customer_order_id: String }. Relationships: (:AircraftBuild)-[:IS_MODEL]->(:AircraftModel {model_id}), (:AircraftBuild)-[:ASSEMBLED_ON]->(:AssemblyLine {line_id}). Index on build_id, serial_number, current_status.\nNode Label ':Inspection'. Properties: { inspection_id: String (Constraint: UNIQUE), inspection_type: String, inspection_timestamp: Datetime, result: String, remarks: String }. Relationships: (:AircraftBuild {build_id})-[:UNDERWENT]->(:Inspection), (:Inspection)-[:PERFORMED_BY]->(:Employee {employee_id}), (:Inspection)-[:INSPECTED_COMPONENT]->(:Component {component_id}) (optional), (:Inspection)-[:FOLLOWED_STEP]->(:AssemblyStep {step_id}) (optional). Index on inspection_id.\nNode Label ':Employee'. Properties: { employee_id: String (Constraint: UNIQUE), first_name: String, last_name: String, job_title: String, skill_certifications: String[], hire_date: Date, employment_status: String }. Relationships: (:Employee)-[:ASSIGNED_TO]->(:AssemblyLine {line_id}), (:Employee)-[:REPORTS_TO]->(:Employee {employee_id as supervisor_id}). Index on employee_id.\nNode Label ':InventoryBatch'. Properties: { inventory_record_id: String (Constraint: UNIQUE), quantity: Integer, location_warehouse: String, location_bin: String, received_date: Datetime, expiry_date: Date, batch_number: String, last_updated: Datetime }. Relationship: (:InventoryBatch)-[:IS_INSTANCE_OF]->(:Component {component_id}). Index on inventory_record_id, component_id.\n"}
{"conversations": [{"role": "user", "content": "Can you show, for each employee, the full name and job title of their direct manager, as well as the employee's department and branch_id?"}, {"role": "assistant", "content": "SELECT e.employee_id, e.first_name AS employee_first_name, e.last_name AS employee_last_name, e.department AS employee_department, e.branch_id AS employee_branch_id, m.first_name AS manager_first_name, m.last_name AS manager_last_name, m.job_title AS manager_job_title\nFROM financial_services.employees e\nLEFT JOIN financial_services.employees m ON e.manager_id = m.employee_id;"}, {"role": "user", "content": "Actually, show only employees who have a manager assigned, and include only those where the manager works at a different branch than the employee."}, {"role": "assistant", "content": "SELECT e.employee_id, e.first_name AS employee_first_name, e.last_name AS employee_last_name, e.department AS employee_department, e.branch_id AS employee_branch_id, m.first_name AS manager_first_name, m.last_name AS manager_last_name, m.job_title AS manager_job_title, m.branch_id AS manager_branch_id\nFROM financial_services.employees e\nINNER JOIN financial_services.employees m ON e.manager_id = m.employee_id\nWHERE e.branch_id IS DISTINCT FROM m.branch_id;"}, {"role": "user", "content": "Now, only include employees who were hired after 2021-01-01."}, {"role": "assistant", "content": "SELECT e.employee_id, e.first_name AS employee_first_name, e.last_name AS employee_last_name, e.department AS employee_department, e.branch_id AS employee_branch_id, m.first_name AS manager_first_name, m.last_name AS manager_last_name, m.job_title AS manager_job_title, m.branch_id AS manager_branch_id\nFROM financial_services.employees e\nINNER JOIN financial_services.employees m ON e.manager_id = m.employee_id\nWHERE e.branch_id IS DISTINCT FROM m.branch_id\n  AND e.hire_date > '2021-01-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE financial_services.transactions (\n    transaction_id character varying(64) NOT NULL, -- unique identifier for the transaction\n    account_id character varying(64) NOT NULL, -- account involved in the transaction\n    related_account_id character varying(64), -- counterpart account for transfers\n    transaction_type character varying(50) NOT NULL, -- e.g., Deposit, Withdrawal, Transfer, Payment, Fee, Interest\n    amount numeric(19, 4) NOT NULL, -- transaction amount\n    currency character varying(3) NOT NULL, -- transaction currency\n    transaction_date timestamp NOT NULL, -- exact time of the transaction\n    effective_date date NOT NULL, -- date the transaction affects the balance\n    description text, -- description or memo of the transaction\n    status character varying(32) NOT NULL, -- e.g., Pending, Completed, Failed, Reversed\n    reference_number character varying(128), -- external reference if applicable (e.g., check number)\n    PRIMARY KEY (transaction_id),\n    FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id),\n    FOREIGN KEY (related_account_id) REFERENCES financial_services.accounts(account_id)\n)\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE financial_services.employees (\n    employee_id character varying(64) NOT NULL,  -- unique identifier for the employee\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    job_title character varying(100) NOT NULL, -- e.g., Teller, Branch Manager, Financial Advisor, Analyst\n    department character varying(100), -- e.g., Retail Banking, Wealth Management, IT\n    branch_id character varying(64), -- Identifier for the branch they work at (if applicable)\n    email character varying(128) NOT NULL UNIQUE,\n    phone_extension character varying(20),\n    hire_date date NOT NULL,\n    termination_date date, -- Date of termination, null if currently employed\n    manager_id character varying(64), -- Self-referencing key for manager relationship\n    status character varying(32) NOT NULL, -- e.g., Active, Terminated, On Leave\n    PRIMARY KEY (employee_id),\n    FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), -- Assuming a branches table exists\n    FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id)\n)\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "What are the maintenance costs for a specific aircraft model like the Airbus A320?"}, {"role": "assistant", "content": "I'm sorry, but I don't have access to data regarding maintenance costs for specific aircraft models such as the Airbus A320. The information in the database is limited to details like model name, manufacturer, passenger capacity, and technical specifications. For maintenance cost information, you may need to consult with the manufacturer or a maintenance service provider."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE manufacturing.aircraft_models ( model_id character varying(64) NOT NULL, model_name character varying(128) NOT NULL, manufacturer character varying(128) NOT NULL, passenger_capacity integer, max_range_km integer, engine_type character varying(100), wingspan_m numeric(6,2), status character varying(50) NOT NULL, first_flight_date date, PRIMARY KEY (model_id) )\n"}
{"conversations": [{"role": "user", "content": "How many hashtags have been created in March 2024?"}, {"role": "assistant", "content": "```sql\nSELECT COUNT(*) AS march_2024_hashtag_count\nFROM social_media.hashtags\nWHERE created_at >= '2024-03-01'\n  AND created_at <  '2024-04-01';\n```"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE social_media.hashtags ( hashtag_id text PRIMARY KEY, tag_name text, created_at timestamp )\nCREATE TABLE social_media.conversation_participants ( participant_id text PRIMARY KEY, conversation_id text, user_id text, joined_at timestamp, last_read_at timestamp )\nCREATE TABLE social_media.notifications ( notification_id text PRIMARY KEY, recipient_user_id text, sender_user_id text, notification_type text, target_entity_id text, target_entity_type text, created_at timestamp, read_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show me the top 5 games by number of online servers in European regions. I want the game title and the server count."}, {"role": "assistant", "content": "SELECT g.title, COUNT(s.server_id) AS server_count\nFROM gaming_technology.games g\nJOIN gaming_technology.servers s ON g.game_id = s.game_id\nWHERE s.region ILIKE 'eu%' AND s.status = 'online'\nGROUP BY g.title\nORDER BY server_count DESC\nLIMIT 5;"}, {"role": "user", "content": "Now include only those games whose average current_players per online server exceeds 100."}, {"role": "assistant", "content": "SELECT g.title,\n       COUNT(s.server_id) AS server_count,\n       AVG(s.current_players)::numeric(10,2) AS avg_players\nFROM gaming_technology.games g\nJOIN gaming_technology.servers s ON g.game_id = s.game_id\nWHERE s.region ILIKE 'eu%' AND s.status = 'online'\nGROUP BY g.title\nHAVING AVG(s.current_players) > 100\nORDER BY server_count DESC\nLIMIT 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.players ( player_id uuid PRIMARY KEY, username text, email text, password_hash text, registration_date timestamptz, last_login timestamptz, country_code text, status text, profile_data jsonb )\nCREATE 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 )\nCREATE TABLE gaming_technology.servers ( server_id uuid PRIMARY KEY, game_id uuid, server_name text, region text, ip_address text, port int, current_players int, max_players int, status text, last_heartbeat timestamptz )\nCREATE TABLE gaming_technology.achievements ( achievement_id uuid PRIMARY KEY, game_id uuid, name text, description text, icon_url text, points int, hidden boolean )\nCREATE TABLE gaming_technology.player_achievements ( player_achievement_id uuid PRIMARY KEY, player_id uuid, achievement_id uuid, unlocked_at timestamptz )\nCREATE TABLE gaming_technology.in_game_items ( item_id uuid PRIMARY KEY, game_id uuid, item_name text, item_type text, description text, rarity text, cost_currency text, cost_amount numeric, attributes jsonb )\nCREATE TABLE gaming_technology.player_inventory ( inventory_id uuid PRIMARY KEY, player_id uuid, item_id uuid, quantity int, acquired_at timestamptz, instance_data jsonb )\n"}
{"conversations": [{"role": "user", "content": "Find all contracts where the deployer address is the same as the contract address, indicating self-deployed contracts, and show their network IDs and deployment timestamps."}, {"role": "assistant", "content": "SELECT address, network_id, deployed_at FROM web3.contracts WHERE address = deployer_address;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.contracts ( contract_id character varying(64) NOT NULL, address character varying(128) NOT NULL, abi text NOT NULL, bytecode text NOT NULL, deployer_address character varying(128) NOT NULL, deployed_at timestamp NOT NULL, network_id character varying(64) NOT NULL, status character varying(32) NOT NULL, PRIMARY KEY (contract_id) )\n"}
{"conversations": [{"role": "user", "content": "List all rooms, including their room number, the name of the property they belong to, and their room type name, specifically for rooms with 'Maintenance' status."}, {"role": "assistant", "content": "SELECT T1.room_number, T2.property_name, T3.type_name FROM rooms AS T1 JOIN properties AS T2 ON T1.property_id = T2.property_id JOIN room_types AS T3 ON T1.room_type_id = T3.room_type_id WHERE T1.status = 'Maintenance'"}, {"role": "user", "content": "Also include the floor number and filter to only show rooms located on floors 5 or higher. Sort the results by property name and then by floor."}, {"role": "assistant", "content": "SELECT T1.room_number, T2.property_name, T3.type_name, T1.floor FROM rooms AS T1 JOIN properties AS T2 ON T1.property_id = T2.property_id JOIN room_types AS T3 ON T1.room_type_id = T3.room_type_id WHERE T1.status = 'Maintenance' AND T1.floor >= 5 ORDER BY T2.property_name, T1.floor"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.rooms (\n    room_id character varying(64) NOT NULL,  -- unique identifier for the room\n    property_id character varying(64) NOT NULL, -- FK to properties table\n    room_number character varying(10) NOT NULL, -- room number identifier (e.g., '101', 'Suite 2B')\n    room_type_id character varying(64) NOT NULL, -- FK to room_types table\n    floor integer, -- floor number the room is on\n    status character varying(50) NOT NULL, -- e.g., Available, Occupied, Cleaning, OutOfOrder, Maintenance\n    is_smoking boolean NOT NULL DEFAULT false, -- smoking allowed flag\n    features text, -- description of features (e.g., Balcony, Sea View, Jacuzzi)\n    current_condition text, -- notes on room condition\n    last_cleaned_at timestamp with time zone, -- timestamp of last cleaning\n    PRIMARY KEY (room_id),\n    FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id),\n    FOREIGN KEY (room_type_id) REFERENCES hospitality_technology.room_types(room_type_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List the first and last names of employees and the full name of the citizens for whom they have scheduled appointments."}, {"role": "assistant", "content": "SELECT T1.first_name ,  T1.last_name ,  T3.first_name ,  T3.last_name FROM government_services.employees AS T1 JOIN government_services.appointments AS T2 ON T1.employee_id  =  T2.employee_id JOIN government_services.citizens AS T3 ON T2.citizen_id  =  T3.citizen_id"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id text PRIMARY KEY, 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 )\nCREATE 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 )\nCREATE TABLE government_services.services ( service_id text PRIMARY KEY, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days int, is_active boolean, online_application_url text )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me the content of all comments that have received at least one like."}, {"role": "assistant", "content": "SELECT DISTINCT T1.content FROM social_media.comments AS T1 JOIN social_media.likes AS T2 ON T1.comment_id = T2.comment_id;"}, {"role": "user", "content": "Also include the creation time of these comments and the user_id of the commenter?"}, {"role": "assistant", "content": "SELECT DISTINCT T1.comment_id, T1.content, T1.created_at, T1.user_id FROM social_media.comments AS T1 JOIN social_media.likes AS T2 ON T1.comment_id = T2.comment_id;"}, {"role": "user", "content": "Only show comments created before '2024-05-01'."}, {"role": "assistant", "content": "SELECT DISTINCT T1.comment_id, T1.content, T1.created_at, T1.user_id FROM social_media.comments AS T1 JOIN social_media.likes AS T2 ON T1.comment_id = T2.comment_id WHERE T1.created_at < '2024-05-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE social_media.comments (\n    comment_id character varying(64) NOT NULL, -- unique identifier for the comment\n    post_id character varying(64) NOT NULL, -- identifier of the post being commented on (FK to posts.post_id)\n    user_id character varying(64) NOT NULL, -- identifier of the user who made the comment (FK to users.user_id)\n    parent_comment_id character varying(64), -- identifier of the parent comment if it's a reply (FK to comments.comment_id)\n    content text NOT NULL, -- textual content of the comment\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of comment creation\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last comment edit\n    PRIMARY KEY (comment_id)\n)\nCREATE TABLE social_media.likes ( like_id text, user_id text, post_id text, comment_id text, created_at timestamp )\nCREATE TABLE social_media.conversations ( conversation_id text PRIMARY KEY, created_at timestamp, last_message_at timestamp, is_group_chat bool, group_name text )\n"}
{"conversations": [{"role": "user", "content": "Show me all rooms that were last cleaned more than 3 days ago, along with their room numbers and cleaning status."}, {"role": "assistant", "content": "SELECT room_number, current_condition FROM hospitality_technology.rooms WHERE last_cleaned_at < CURRENT_DATE - INTERVAL '3 days';"}, {"role": "user", "content": "Now, join this with another query to show only rooms that are currently 'Available' and have a 'Jacuzzi' in their features."}, {"role": "assistant", "content": "SELECT r.room_number, r.current_condition FROM hospitality_technology.rooms r WHERE r.last_cleaned_at < CURRENT_DATE - INTERVAL '3 days' AND r.status = 'available' AND r.features LIKE '%Jacuzzi%';"}, {"role": "user", "content": "The query is missing the floor information. Can you include that as well?"}, {"role": "assistant", "content": "SELECT r.room_number, r.current_condition, r.floor FROM hospitality_technology.rooms r WHERE r.last_cleaned_at < CURRENT_DATE - INTERVAL '3 days' AND r.status = 'available' AND r.features LIKE '%Jacuzzi%';"}, {"role": "user", "content": "Actually, I need to see the results ordered by floor in descending order, then by room_number."}, {"role": "assistant", "content": "SELECT r.room_number, r.current_condition, r.floor FROM hospitality_technology.rooms r WHERE r.last_cleaned_at < CURRENT_DATE - INTERVAL '3 days' AND r.status = 'available' AND r.features LIKE '%Jacuzzi%' ORDER BY r.floor DESC, r.room_number;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.rooms ( room_id text PRIMARY KEY, property_id text, room_number text, room_type_id text, floor int, status text, is_smoking boolean, features text, current_condition text, last_cleaned_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List lawyers who have any unbilled time entries. Show their first name, last name, and the count of their unbilled entries."}, {"role": "assistant", "content": "SELECT T1.first_name, T1.last_name, COUNT(T2.entry_id) FROM lawyers AS T1 JOIN time_entries AS T2 ON T1.lawyer_id = T2.lawyer_id WHERE T2.is_billed = false GROUP BY T1.lawyer_id, T1.first_name, T1.last_name;"}, {"role": "user", "content": "Modify that query to only include entries marked as billable, and instead show the total hours spent rather than the count."}, {"role": "assistant", "content": "SELECT T1.first_name, T1.last_name, SUM(T2.hours_spent) FROM lawyers AS T1 JOIN time_entries AS T2 ON T1.lawyer_id = T2.lawyer_id WHERE T2.is_billed = false AND T2.is_billable = true GROUP BY T1.lawyer_id, T1.first_name, T1.last_name;"}, {"role": "user", "content": "Now, only show lawyers with more than 10 unbilled billable hours in total, and sort the results by the total hours descending."}, {"role": "assistant", "content": "SELECT T1.first_name, T1.last_name, SUM(T2.hours_spent) FROM lawyers AS T1 JOIN time_entries AS T2 ON T1.lawyer_id = T2.lawyer_id WHERE T2.is_billed = false AND T2.is_billable = true GROUP BY T1.lawyer_id, T1.first_name, T1.last_name HAVING SUM(T2.hours_spent) > 10 ORDER BY SUM(T2.hours_spent) DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.lawyers ( lawyer_id text PRIMARY KEY, first_name text, last_name text, bar_number text UNIQUE, firm_id text, email text UNIQUE, phone text, specialization text, hire_date timestamp, is_partner bool )\nCREATE TABLE legal_services.law_firms ( firm_id text PRIMARY KEY, firm_name text, address text, phone text, website text, founded_date date, managing_partner_id text )\nCREATE TABLE legal_services.documents ( document_id text PRIMARY KEY, case_id text, document_name text, document_type text, storage_path text, uploaded_by_lawyer_id text, upload_timestamp timestamp, version int, description text )\nCREATE TABLE legal_services.time_entries ( entry_id text PRIMARY KEY, case_id text, lawyer_id text, date_worked date, hours_spent numeric, billing_rate numeric, description text, is_billable bool, is_billed bool, invoice_id text, created_at timestamp )\nCREATE TABLE legal_services.invoices ( invoice_id text PRIMARY KEY, invoice_number text UNIQUE, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )\nCREATE TABLE legal_services.appointments ( appointment_id text PRIMARY KEY, client_id text, lawyer_id text, case_id text, start_time timestamp, end_time timestamp, location text, subject text, notes text, status text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "What is the performance review score for employee with ID 'EMP456' for the last quarter?"}, {"role": "assistant", "content": "I'm sorry, but I can't assist with information about performance review scores as this data is not included in the employees table."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE manufacturing.employees ( employee_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, job_title character varying(128) NOT NULL, skill_certifications text, hire_date date NOT NULL, assigned_line_id character varying(64), employment_status character varying(50) NOT NULL, supervisor_employee_id character varying(64), PRIMARY KEY (employee_id) )\n"}
{"conversations": [{"role": "user", "content": "List the employee full names, the department they work in, and the number of notifications sent to citizens who have made payments for the services managed by these employees' agencies."}, {"role": "assistant", "content": "SELECT e.first_name || ' ' || e.last_name AS employee_full_name, e.department, COUNT(n.notification_id) AS notification_count\nFROM government_services.employees e\nJOIN government_services.services s ON e.agency_id = s.agency_id\nJOIN government_services.payments p ON s.service_id = p.service_id\nJOIN government_services.notifications n ON p.citizen_id = n.citizen_id\nGROUP BY e.employee_id, e.first_name, e.last_name, e.department;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id text PRIMARY KEY, 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 )\nCREATE TABLE government_services.services ( service_id text PRIMARY KEY, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days int, is_active boolean, online_application_url text )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Provide the count of diagnoses by status."}, {"role": "assistant", "content": "SELECT status,\n       COUNT(*) AS count\nFROM healthcare.diagnoses\nGROUP BY status;"}, {"role": "user", "content": "Now only include statuses with more than 10 diagnoses."}, {"role": "assistant", "content": "SELECT status,\n       COUNT(*) AS count\nFROM healthcare.diagnoses\nGROUP BY status\nHAVING COUNT(*) > 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.diagnoses (\n    diagnosis_id character varying(64) NOT NULL, -- unique identifier for the diagnosis entry\n    record_id character varying(64) NOT NULL, -- FK linking to the specific medical record entry\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    doctor_id character varying(64) NOT NULL, -- FK to doctors table (diagnosing doctor)\n    diagnosis_code character varying(20) NOT NULL, -- standard code (e.g., ICD-10)\n    code_type character varying(10) NOT NULL DEFAULT 'ICD-10', -- type of code used\n    description text, -- textual description of the diagnosis\n    diagnosis_date date NOT NULL, -- date the diagnosis was made\n    status character varying(32) NOT NULL, -- e.g., Active, Resolved, Ruled Out\n    is_chronic boolean DEFAULT false, -- flag for chronic conditions\n    PRIMARY KEY (diagnosis_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show the route number and description for routes that have bookings associated with them."}, {"role": "assistant", "content": "SELECT DISTINCT T1.route_number, T1.description FROM transportation.routes AS T1 JOIN transportation.bookings AS T2 ON T1.route_id = T2.trip_id;"}, {"role": "user", "content": "For these routes, what is the average fare of the associated bookings?"}, {"role": "assistant", "content": "SELECT T1.route_number, AVG(T2.fare) FROM transportation.routes AS T1 JOIN transportation.bookings AS T2 ON T1.route_id = T2.trip_id GROUP BY T1.route_number;"}, {"role": "user", "content": "Also, only include routes where the average fare is greater than 75."}, {"role": "assistant", "content": "SELECT T1.route_number, AVG(T2.fare) FROM transportation.routes AS T1 JOIN transportation.bookings AS T2 ON T1.route_id = T2.trip_id GROUP BY T1.route_number HAVING AVG(T2.fare) > 75;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE transportation.routes ( route_id text, route_number text, description text, origin_location_id text, destination_location_id text, distance_km numeric, estimated_duration_minutes integer, type text )\nCREATE TABLE transportation.bookings ( booking_id.text, passenger_id.text, trip_id.text, seat_number.text, booking_time.timestamp, status.text, fare.numeric, payment_transaction_id.text, special_requests.text )\n"}
{"conversations": [{"role": "user", "content": "List all pairs of wallets that were created within 10 minutes of each other, showing both wallet IDs, the user_id, and both creation timestamps."}, {"role": "assistant", "content": "SELECT\n  w1.wallet_id AS wallet1_id,\n  w2.wallet_id AS wallet2_id,\n  w1.user_id,\n  w1.created_at AS created_at1,\n  w2.created_at AS created_at2\nFROM web3.wallets w1\nJOIN web3.wallets w2\n  ON w1.user_id = w2.user_id\n  AND w1.wallet_id < w2.wallet_id\n  AND ABS(EXTRACT(EPOCH FROM (w1.created_at - w2.created_at))) <= 600;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List the usernames of players who own at least one item from the game with title 'Game Title X'."}, {"role": "assistant", "content": "SELECT DISTINCT T1.username FROM players AS T1 INNER JOIN player_inventory AS T2 ON T1.player_id = T2.player_id INNER JOIN items AS T3 ON T2.item_id = T3.item_id INNER JOIN games AS T4 ON T3.game_id = T4.game_id WHERE T4.title = 'Game Title X';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "List all appointments that are currently scheduled and show their appointment time."}, {"role": "assistant", "content": "SELECT appointment_id, patient_id, doctor_id, appointment_time FROM healthcare.appointments WHERE status = 'Scheduled';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.patients ( patient_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, date_of_birth date NOT NULL, gender character varying(10), address text, phone_number character varying(20), email character varying(128) UNIQUE, emergency_contact_name character varying(200), emergency_contact_phone character varying(20), created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (patient_id) )\nCREATE TABLE healthcare.appointments ( appointment_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, appointment_time timestamp with time zone NOT NULL, duration_minutes integer NOT NULL, reason text, status character varying(32) NOT NULL, location_id character varying(64), notes text, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (appointment_id) )\nCREATE TABLE healthcare.patient_insurance ( patient_insurance_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, plan_id character varying(64) NOT NULL, policy_number character varying(100) NOT NULL, group_number character varying(100), subscriber_name character varying(200), effective_date date NOT NULL, expiration_date date, is_primary boolean NOT NULL DEFAULT true, PRIMARY KEY (patient_insurance_id), UNIQUE (patient_id, plan_id, policy_number) )\n"}
{"conversations": [{"role": "user", "content": "List all log entries associated with users who have participated in any trade, showing the log details and the trade ID."}, {"role": "assistant", "content": "SELECT T1.log_id, T1.action, T1.details, T1.logged_at, T2.trade_id, T2.buyer_id, T2.seller_id FROM logs AS T1 JOIN trades AS T2 ON T1.user_id = T2.buyer_id OR T1.user_id = T2.seller_id;"}, {"role": "user", "content": "Only show logs and trades that occurred in the last week."}, {"role": "assistant", "content": "SELECT T1.log_id, T1.action, T1.details, T1.logged_at, T2.trade_id, T2.buyer_id, T2.seller_id FROM logs AS T1 JOIN trades AS T2 ON T1.user_id = T2.buyer_id OR T1.user_id = T2.seller_id WHERE T1.logged_at >= datetime('now', '-7 days') AND T2.traded_at >= datetime('now', '-7 days');"}, {"role": "user", "content": "Can you instead provide a count of such log entries per user who traded, for the last week?"}, {"role": "assistant", "content": "SELECT T1.user_id, COUNT(DISTINCT T1.log_id) AS log_count FROM logs AS T1 JOIN trades AS T2 ON T1.user_id = T2.buyer_id OR T1.user_id = T2.seller_id WHERE T1.logged_at >= datetime('now', '-7 days') AND T2.traded_at >= datetime('now', '-7 days') GROUP BY T1.user_id;"}, {"role": "user", "content": "Also include the total number of trades for each user in the same period and sort by trade count descending."}, {"role": "assistant", "content": "SELECT T1.user_id, COUNT(DISTINCT T1.log_id) AS log_count, COUNT(DISTINCT T2.trade_id) AS trade_count FROM logs AS T1 JOIN trades AS T2 ON T1.user_id = T2.buyer_id OR T1.user_id = T2.seller_id WHERE T1.logged_at >= datetime('now', '-7 days') AND T2.traded_at >= datetime('now', '-7 days') GROUP BY T1.user_id ORDER BY trade_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.wallets ( wallet_id.text, user_id.text, address.text, private_key.text, created_at.timestamp )\nCREATE TABLE trading_platform.trades ( trade_id.text, order_id.text, buyer_id.text, seller_id.text, asset_id.text, quantity.numeric, price.numeric, traded_at.timestamp )\nCREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )\nCREATE TABLE trading_platform.dapps ( dapp_id.text, name.text, description.text, url.text )\nCREATE TABLE trading_platform.peers ( peer_id.text, ip_address.text, port.integer, last_seen.timestamp )\nCREATE TABLE trading_platform.logs ( log_id.text, user_id.text, action.text, details.text, logged_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "List all DApps along with the number of metadata entries linked to each, even if the DApp has no linked metadata."}, {"role": "assistant", "content": "SELECT d.name, d.url, COUNT(m.metadata_id) AS metadata_count\nFROM trading_platform.dapps d\nLEFT JOIN trading_platform.metadata m ON d.dapp_id = m.asset_id\nGROUP BY d.dapp_id, d.name, d.url;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.users ( user_id.text, username.text, email.text, password_hash.text, created_at.timestamp )\nCREATE TABLE trading_platform.orders ( order_id text, user_id text, wallet_id text, asset_id text, order_type text, quantity numeric, price numeric, status text, created_at timestamp )\nCREATE TABLE trading_platform.assets ( asset_id text, name text, symbol text, type text )\nCREATE TABLE trading_platform.dapps ( dapp_id text, name text, description text, url text )\nCREATE TABLE trading_platform.peers ( peer_id.text, ip_address.text, port.integer, last_seen.timestamp )\nCREATE TABLE trading_platform.metadata ( metadata_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, key character varying(128) NOT NULL, value text NOT NULL, PRIMARY KEY (metadata_id) )\nCREATE TABLE trading_platform.logs ( log_id text PRIMARY KEY, user_id text, action text, details text, logged_at timestamp )\nCREATE TABLE trading_platform.notifications ( notification_id text, user_id text, message text, sent_at timestamp, read_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "For each fundraising round in 2022 and 2023, list the round name, the year, the total investment_value, and the count of distinct projects. Also include the average market_cap of associated tokens by matching project_name to token_symbol in token_basic_info."}, {"role": "assistant", "content": "SELECT p.rounds_name,\n  SUBSTRING(p.investment_date FROM 1 FOR 4) AS year,\n  SUM(p.investment_value) AS total_investment,\n  COUNT(DISTINCT p.project_id) AS project_count,\n  AVG(t.market_cap) AS avg_market_cap\nFROM project_fundraising_record p\nJOIN token_basic_info t\n  ON LOWER(p.project_name) = LOWER(t.token_symbol)\nWHERE SUBSTRING(p.investment_date FROM 1 FOR 4) IN ('2022','2023')\nGROUP BY p.rounds_name, SUBSTRING(p.investment_date FROM 1 FOR 4);"}, {"role": "user", "content": "The join returns no rows. Please change the join to match when token_symbol is contained within project_name, case-insensitive."}, {"role": "assistant", "content": "SELECT p.rounds_name,\n  SUBSTRING(p.investment_date FROM 1 FOR 4) AS year,\n  SUM(p.investment_value) AS total_investment,\n  COUNT(DISTINCT p.project_id) AS project_count,\n  AVG(t.market_cap) AS avg_market_cap\nFROM project_fundraising_record p\nJOIN token_basic_info t\n  ON LOWER(p.project_name) LIKE '%' || LOWER(t.token_symbol) || '%'\nWHERE SUBSTRING(p.investment_date FROM 1 FOR 4) IN ('2022','2023')\nGROUP BY p.rounds_name, SUBSTRING(p.investment_date FROM 1 FOR 4);"}, {"role": "user", "content": "Now only include rounds where the total investment_value exceeds 5000000."}, {"role": "assistant", "content": "SELECT p.rounds_name,\n  SUBSTRING(p.investment_date FROM 1 FOR 4) AS year,\n  SUM(p.investment_value) AS total_investment,\n  COUNT(DISTINCT p.project_id) AS project_count,\n  AVG(t.market_cap) AS avg_market_cap\nFROM project_fundraising_record p\nJOIN token_basic_info t\n  ON LOWER(p.project_name) LIKE '%' || LOWER(t.token_symbol) || '%'\nWHERE SUBSTRING(p.investment_date FROM 1 FOR 4) IN ('2022','2023')\nGROUP BY p.rounds_name, SUBSTRING(p.investment_date FROM 1 FOR 4)\nHAVING SUM(p.investment_value) > 5000000;"}, {"role": "user", "content": "Finally, order the results by total_investment descending."}, {"role": "assistant", "content": "SELECT p.rounds_name,\n  SUBSTRING(p.investment_date FROM 1 FOR 4) AS year,\n  SUM(p.investment_value) AS total_investment,\n  COUNT(DISTINCT p.project_id) AS project_count,\n  AVG(t.market_cap) AS avg_market_cap\nFROM project_fundraising_record p\nJOIN token_basic_info t\n  ON LOWER(p.project_name) LIKE '%' || LOWER(t.token_symbol) || '%'\nWHERE SUBSTRING(p.investment_date FROM 1 FOR 4) IN ('2022','2023')\nGROUP BY p.rounds_name, SUBSTRING(p.investment_date FROM 1 FOR 4)\nHAVING SUM(p.investment_value) > 5000000\nORDER BY total_investment DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE project_fundraising_record ( id character varying(32) NOT NULL, project_id character varying(32) NOT NULL, project_name character varying(128) NOT NULL, rounds_name character varying(32), investment_value numeric(38,14), investment_date character varying(128), introduction character varying(128), valuation numeric(38,14) )\nCREATE 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 )\n \"CREATE TABLE narrative_info (\",\n    \"narrative character varying(512) NOT NULL, -- the id of narrative\",\n    \"top_3_coins text, -- the top 3 tokens in the narrative\",\n    \"price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour in the narrative\",\n    \"price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours in the narrative\",\n    \"price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days in the narrative\",\n    \"market_cap double precision, -- the market cap of the narrative\",\n    \"volume_24h double precision, -- the trade volume of the narrative\",\n    \"trend_rank bigint, -- the trending rank of the narrative, value 1 expresses the most popular narrative\",\n    \"token_num bigint, -- total token number in the narrative\",\n    \",PRIMARY KEY (narrative));\"\n\nCREATE TABLE token_dexpool_info ( pair_address character varying(512) NOT NULL, -- the id of dexpool token_name character varying(100) NOT NULL, -- the name of the token in the dexpool token_symbol character varying(100) NOT NULL, -- the token's symbol chain text, -- the chain that the dexpool resides price double precision, -- the current price of the token price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour price_change_percentage_6h double precision, -- change in value divided by the absolute price value of the original token price in 6 hours price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours makers_24h double precision, -- the makers of the dex pool in 24 hours volume_24h double precision, -- the trade volume of the dex pool in 24 hours liquidity double precision, -- the liquidity of the dex pool market_cap double precision, -- the market cap of the token trend_rank bigint, -- the rank of token in the dex pool of recent trending, value 1 expresses the most popular token. ,PRIMARY KEY (pair_address, chain) )\n  \"CREATE TABLE cex_token_balance (\",\n    \"snapshot_time character varying(32) NOT NULL,  -- the snapshot time of record, converted from original timestamp\",\n    \"chain character varying(128) NOT NULL, -- the chain that the token resides\",\n    \"address character varying(128) NOT NULL, -- the address that holds the assets, owned by a CEX\",\n    \"exchange character varying(512) NOT NULL, -- a centralized exchange name\",\n    \"token_address character varying(128) NOT NULL, -- token contract address\",\n    \"token_symbol character varying(512), --token symbol\",\n    \"balance numeric(38,10), -- token balance\",\n    \"usd_value numeric(38,14), -- value of the token held in USD\",\n    \"price double precision, --price of the token in USD\",\n    \",PRIMARY KEY (snapshot_time, exchange, address, chain, token_address));\"\n\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List each patient's first and last name along with their total number of appointments in 2024."}, {"role": "assistant", "content": "SELECT p.first_name, p.last_name, COUNT(a.appointment_id) AS appointment_count\nFROM healthcare.patients p\nLEFT JOIN healthcare.appointments a\n  ON p.patient_id = a.patient_id\n  AND a.appointment_time BETWEEN '2024-01-01' AND '2024-12-31'\nGROUP BY p.first_name, p.last_name;"}, {"role": "user", "content": "Now exclude all 'Cancelled' appointments from the count."}, {"role": "assistant", "content": "SELECT p.first_name, p.last_name, COUNT(a.appointment_id) AS appointment_count\nFROM healthcare.patients p\nLEFT JOIN healthcare.appointments a\n  ON p.patient_id = a.patient_id\n  AND a.appointment_time BETWEEN '2024-01-01' AND '2024-12-31'\n  AND a.status <> 'Cancelled'\nGROUP BY p.first_name, p.last_name;"}, {"role": "user", "content": "Also, only show patients who have more than 2 appointments and sort the result by appointment_count in descending order."}, {"role": "assistant", "content": "SELECT p.first_name, p.last_name, COUNT(a.appointment_id) AS appointment_count\nFROM healthcare.patients p\nLEFT JOIN healthcare.appointments a\n  ON p.patient_id = a.patient_id\n  AND a.appointment_time BETWEEN '2024-01-01' AND '2024-12-31'\n  AND a.status <> 'Cancelled'\nGROUP BY p.first_name, p.last_name\nHAVING COUNT(a.appointment_id) > 2\nORDER BY appointment_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.patients (\n    patient_id character varying(64) NOT NULL,  -- unique identifier for the patient\n    first_name character varying(100) NOT NULL, -- patient's first name\n    last_name character varying(100) NOT NULL, -- patient's last name\n    date_of_birth date NOT NULL, -- patient's date of birth\n    gender character varying(10), -- patient's gender (e.g., Male, Female, Other)\n    address text, -- patient's home address\n    phone_number character varying(20), -- patient's phone number\n    email character varying(128) UNIQUE, -- patient's email address\n    emergency_contact_name character varying(200), -- name of emergency contact\n    emergency_contact_phone character varying(20), -- phone number of emergency contact\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record creation time\n    updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record last update time\n    PRIMARY KEY (patient_id)\n)\nCREATE TABLE healthcare.appointments (\n    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    doctor_id character varying(64) NOT NULL, -- FK to doctors table\n    appointment_time timestamp with time zone NOT NULL, -- date and time of the appointment\n    duration_minutes integer NOT NULL, -- expected duration in minutes\n    reason text, -- reason for the visit\n    status character varying(32) NOT NULL, -- e.g., Scheduled, Completed, Cancelled, No-show\n    location_id character varying(64), -- FK to a potential locations/clinics table\n    notes text, -- notes related to scheduling\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (appointment_id)\n)\nCREATE TABLE healthcare.medical_records (\n    record_id character varying(64) NOT NULL,  -- unique identifier for the medical record entry\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    appointment_id character varying(64) UNIQUE, -- FK to appointments table (can be null if record not tied to specific appt)\n    doctor_id character varying(64) NOT NULL, -- FK to doctors table (doctor creating the record)\n    record_date timestamp with time zone NOT NULL, -- date the record/observation was made\n    chief_complaint text, -- patient's primary reason for visit\n    present_illness_history text, -- detailed history of the current issue\n    past_medical_history text, -- relevant past conditions/surgeries\n    physical_examination_notes text, -- findings from the physical exam\n    assessment text, -- doctor's assessment/diagnosis summary\n    treatment_plan text, -- planned course of action\n    vitals jsonb, -- store vitals like BP, HR, Temp as structured JSON\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (record_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me the top 5 most recently minted NFTs on the Ethereum blockchain with their contract_address, token_id, name, and rarity_score from nft_metadata."}, {"role": "assistant", "content": "SELECT contract_address, token_id, name, rarity_score\nFROM nft_metadata\nWHERE blockchain = 'Ethereum'\nORDER BY mint_block_number DESC\nLIMIT 5;"}, {"role": "user", "content": "Also include the collection name, floor_price, and token_count from nft_collections for each NFT's collection."}, {"role": "assistant", "content": "SELECT m.contract_address AS nft_contract,\n       m.token_id,\n       m.name,\n       m.rarity_score,\n       c.name       AS collection_name,\n       c.floor_price,\n       c.token_count\nFROM nft_metadata m\nJOIN nft_collections c\n  ON m.blockchain = c.blockchain\n AND m.contract_address = c.contract_address\nWHERE m.blockchain = 'Ethereum'\nORDER BY m.mint_block_number DESC\nLIMIT 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE erc20_balances ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk varchar )\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address text, wallet_address text, amount text, pk integer )\nCREATE TABLE nft_holders ( block_number.bigint, contract_address.text, wallet_address.text, token_id.text, contract_type.text, amount.text, pk.text )\nCREATE TABLE nft_holder_historical (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    contract_address varchar NOT NULL, -- Event contract address\n    wallet_address varchar NOT NULL, -- The wallet address for the contract(with bloom filter)\n    token_id varchar NOT NULL, -- NFT token id\n    contract_type varchar NOT NULL, -- NFT contract type\n    amount varchar NOT NULL, -- The quantity held in the wallet\n    pk integer NOT NULL  -- Partition key for the table(floor(block_number / 7200))\n)\nCREATE TABLE sui_coins ( object_id varchar NOT NULL, status varchar NOT NULL, coin_type varchar NOT NULL, balance varchar NOT NULL, owner varchar NOT NULL )\nCREATE TABLE sui_coins_metadata (\n    object_id varchar NOT NULL, -- object id of the coin metadata object\n    coin_type varchar NOT NULL, -- coin type, eg. 0x...66::reap_token::REAP_TOKEN\n    status varchar NOT NULL, -- coin status, eg. exists, deleted\n    decimals bigint NOT NULL, -- decimals of the coin\n    description varchar NOT NULL, -- description of the coin\n    icon_url varchar NOT NULL, -- icon url of the coin\n    symbol varchar NOT NULL, -- symbol of the coin\n    name varchar NOT NULL  -- name of the coin\n)\nCREATE TABLE nft_metadata ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, token_id varchar NOT NULL, contract_name varchar NOT NULL, erc_type varchar NOT NULL, amount bigint NOT NULL, minter varchar NOT NULL, owner varchar NOT NULL, mint_block_number bigint NOT NULL, mint_time bigint NOT NULL, mint_transaction_hash varchar NOT NULL, mint_price varchar NOT NULL, token_uri varchar NOT NULL, metadata varchar NOT NULL, name varchar NOT NULL, image_uri varchar NOT NULL, traits varchar NOT NULL, updated_at bigint NOT NULL, status varchar NOT NULL, rarity_score real NOT NULL, rarity_rank integer NOT NULL, unique_attribute_count integer NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_prices ( uuid.text, blockchain.text, address.text, decimals.bigint, symbol.text, price.real, timestamp.timestamp )\nCREATE TABLE token_balances (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar NOT NULL, -- Token tick\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply decimal(38,0) NOT NULL, -- Max supply\n    amount decimal(38,0) NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE 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 )\nCREATE TABLE mud_holesky_redstone ( address text, table_id text, key_bytes text, key0 text, key1 text, static_data text, encoded_lengths text, dynamic_data text, is_deleted boolean, block_number bigint, log_index bigint )\nCREATE 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 )\nCREATE TABLE token_balances_avalanche (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar(20) NOT NULL, -- Ticker: Identifier of the inscription\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply decimal(38,0) NOT NULL, -- Max supply: Set max supply of the inscription\n    amount decimal(38,0) NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me the object ID, coin type, and balance for all SUI coins where the status is 'active'."}, {"role": "assistant", "content": "SELECT object_id, coin_type, balance FROM sui_coins WHERE status = 'active'"}, {"role": "user", "content": "Also, include the owner address in the result."}, {"role": "assistant", "content": "SELECT object_id, coin_type, balance, owner FROM sui_coins WHERE status = 'active'"}, {"role": "user", "content": "Filter the results to only show coins where the balance is greater than '100000000000'."}, {"role": "assistant", "content": "SELECT object_id, coin_type, balance, owner FROM sui_coins WHERE status = 'active' AND CAST(balance AS NUMERIC) > 100000000000"}, {"role": "user", "content": "Sort the results by balance in descending order and limit the output to 10."}, {"role": "assistant", "content": "SELECT object_id, coin_type, balance, owner FROM sui_coins WHERE status = 'active' AND CAST(balance AS NUMERIC) > 100000000000 ORDER BY CAST(balance AS NUMERIC) DESC LIMIT 10"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE token_metas ( block_timestamp timestamp(6) NOT NULL, block_number bigint NOT NULL, transaction_hash varchar NOT NULL, transaction_index bigint NOT NULL, from_address varchar NOT NULL, contract_address varchar NOT NULL, symbol varchar NOT NULL, total_supply varchar NOT NULL, name varchar NOT NULL, decimals bigint NOT NULL, is_erc20 integer NOT NULL, is_erc721 integer NOT NULL, is_erc1155 integer NOT NULL, is_proxy integer NOT NULL, extra_info varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE nft_holder_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE sui_coins ( object_id varchar NOT NULL, status varchar NOT NULL, coin_type varchar NOT NULL, balance varchar NOT NULL, owner varchar NOT NULL )\nCREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_prices ( uuid varchar(36) NOT NULL, blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )\nCREATE TABLE token_prices_latest ( blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )\nCREATE TABLE token_info ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL )\nCREATE TABLE token_activities ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar NOT NULL, tick varchar NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(42) NOT NULL, to_address varchar(42) NOT NULL )\nCREATE TABLE token_balances_bitcoin ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar(255) NOT NULL, wallet_address varchar(42) NOT NULL, total_supply varchar NOT NULL, amount varchar NOT NULL )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(62) NOT NULL, to_address varchar(62) NOT NULL )\nCREATE TABLE token_activities_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(42) NOT NULL, to_address varchar(42) NOT NULL )\nCREATE TABLE token_balances_avalanche ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar(20) NOT NULL, wallet_address varchar(42) NOT NULL, total_supply decimal(38,0) NOT NULL, amount decimal(38,0) NOT NULL )\nCREATE TABLE token_info_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar(20) NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL, minted decimal(38,0) NOT NULL, holders decimal(38,0) NOT NULL, txs decimal(38,0) NOT NULL, updated_timestamp timestamp(3) NOT NULL, completed_timestamp timestamp(3) NOT NULL, id varchar(255) NOT NULL )\n"}
{"conversations": [{"role": "user", "content": "List each guest’s full name and the total number of service orders they have placed, ordered by order count descending."}, {"role": "assistant", "content": "SELECT g.guest_id,\n       g.first_name || ' ' || g.last_name AS full_name,\n       COUNT(so.order_id) AS order_count\nFROM hospitality_technology.guests g\nLEFT JOIN hospitality_technology.service_orders so\n  ON g.guest_id = so.guest_id\nGROUP BY g.guest_id, full_name\nORDER BY order_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.guests ( guest_id text PRIMARY KEY, first_name text, last_name text, email text, phone_number text, date_of_birth date, address_line1 text, city text, state_province text, postal_code text, country_code text, preferences text, loyalty_member_id text, communication_consent boolean, created_at timestamp, updated_at timestamp )\nCREATE TABLE hospitality_technology.reservations ( reservation_id text, property_id text, guest_id text, room_id text, room_type_id text, check_in_date date, check_out_date date, actual_check_in_ts timestamp, actual_check_out_ts timestamp, num_adults integer, num_children integer, status text, booking_source text, rate_plan_id text, total_amount numeric, amount_paid numeric, special_requests text, created_at timestamp, updated_at timestamp )\nCREATE TABLE hospitality_technology.service_orders ( order_id.text, reservation_id.text, guest_id.text, service_id.text, staff_id_ordered.text, staff_id_delivered.text, order_timestamp.timestamp, delivery_timestamp.timestamp, quantity.integer, unit_price.numeric, total_price.numeric, status.text, notes.text, bill_id.text )\nCREATE TABLE hospitality_technology.reviews ( review_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, reservation_id character varying(64) UNIQUE, guest_id character varying(64) NOT NULL, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source character varying(100), review_date timestamp with time zone NOT NULL DEFAULT current_timestamp, is_public boolean DEFAULT true, staff_response text, response_staff_id character varying(64), response_date timestamp with time zone, PRIMARY KEY (review_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (response_staff_id) REFERENCES hospitality_technology.staff(staff_id) )\n"}
{"conversations": [{"role": "user", "content": "Show me all active managers along with their property IDs and the number of staff members they supervise, ordered by the number of supervised staff in descending order."}, {"role": "assistant", "content": "SELECT s.staff_id, s.property_id, s.first_name, s.last_name, COUNT(s2.staff_id) AS supervised_staff_count FROM hospitality_technology.staff s LEFT JOIN hospitality_technology.staff s2 ON s.staff_id = s2.manager_id WHERE s.position = 'Manager' AND s.is_active = true GROUP BY s.staff_id, s.property_id, s.first_name, s.last_name ORDER BY supervised_staff_count DESC;"}, {"role": "user", "content": "Now, include only managers who supervise at least 3 staff members and show their email addresses as well."}, {"role": "assistant", "content": "SELECT s.staff_id, s.property_id, s.first_name, s.last_name, s.work_email, COUNT(s2.staff_id) AS supervised_staff_count FROM hospitality_technology.staff s LEFT JOIN hospitality_technology.staff s2 ON s.staff_id = s2.manager_id WHERE s.position = 'Manager' AND s.is_active = true GROUP BY s.staff_id, s.property_id, s.first_name, s.last_name, s.work_email HAVING COUNT(s2.staff_id) >= 3 ORDER BY supervised_staff_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.staff (\n    staff_id character varying(64) NOT NULL,  -- unique identifier for the staff member\n    property_id character varying(64) NOT NULL, -- FK to properties table (primary property)\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    position character varying(100) NOT NULL, -- e.g., Front Desk Agent, Housekeeper, Manager, Concierge\n    work_email character varying(255) UNIQUE, -- staff member's work email\n    work_phone character varying(30),\n    hire_date date NOT NULL,\n    termination_date date, -- date employment ended (if applicable)\n    is_active boolean NOT NULL DEFAULT true, -- currently employed flag\n    access_level integer NOT NULL, -- permission level within systems (e.g., 1=basic, 5=admin)\n    manager_id character varying(64), -- FK to staff table (self-referencing for supervisor)\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (staff_id),\n    FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id),\n    FOREIGN KEY (manager_id) REFERENCES hospitality_technology.staff(staff_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Calculate the total value of unspent UTXOs for each user whose KYC status has been 'approved'."}, {"role": "assistant", "content": "SELECT kyc.user_id, SUM(u.amount) FROM trading_platform.kyc_audit kyc JOIN trading_platform.utxos u ON kyc.user_id = u.user_id WHERE kyc.status = 'approved' AND u.spent = false GROUP BY kyc.user_id;"}, {"role": "user", "content": "Refine that to only show users where this total value exceeds 1000."}, {"role": "assistant", "content": "SELECT kyc.user_id, SUM(u.amount) FROM trading_platform.kyc_audit kyc JOIN trading_platform.utxos u ON kyc.user_id = u.user_id WHERE kyc.status = 'approved' AND u.spent = false GROUP BY kyc.user_id HAVING SUM(u.amount) > 1000;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )\nCREATE TABLE trading_platform.kyc_audit ( kyc_audit_id.text, user_id.text, status.text, reviewed_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "List all public reviews including the property name, guest full name, overall rating, and comment."}, {"role": "assistant", "content": "SELECT T2.property_name, T3.first_name || ' ' || T3.last_name AS guest_full_name, T1.rating_overall, T1.comment FROM hospitality_technology.reviews AS T1 INNER JOIN hospitality_technology.properties AS T2 ON T1.property_id = T2.property_id INNER JOIN hospitality_technology.guests AS T3 ON T1.guest_id = T3.guest_id WHERE T1.is_public = TRUE;"}, {"role": "user", "content": "Only include reviews with an overall rating of 5."}, {"role": "assistant", "content": "SELECT T2.property_name, T3.first_name || ' ' || T3.last_name AS guest_full_name, T1.rating_overall, T1.comment FROM hospitality_technology.reviews AS T1 INNER JOIN hospitality_technology.properties AS T2 ON T1.property_id = T2.property_id INNER JOIN hospitality_technology.guests AS T3 ON T1.guest_id = T3.guest_id WHERE T1.is_public = TRUE AND T1.rating_overall = 5;"}, {"role": "user", "content": "Also, order the results by review date descending."}, {"role": "assistant", "content": "SELECT T2.property_name, T3.first_name || ' ' || T3.last_name AS guest_full_name, T1.rating_overall, T1.comment FROM hospitality_technology.reviews AS T1 INNER JOIN hospitality_technology.properties AS T2 ON T1.property_id = T2.property_id INNER JOIN hospitality_technology.guests AS T3 ON T1.guest_id = T3.guest_id WHERE T1.is_public = TRUE AND T1.rating_overall = 5 ORDER BY T1.review_date DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties ( property_id text PRIMARY KEY, property_name text, address_line1 text, address_line2 text, city text, state_province text, postal_code text, country_code text, phone_number text, email_address text, property_type text, star_rating numeric, timezone text, manager_staff_id text, created_at timestamp, updated_at timestamp )\nCREATE TABLE hospitality_technology.rooms ( room_id text PRIMARY KEY, property_id text, room_number text, room_type_id text, floor int, status text, is_smoking boolean, features text, current_condition text, last_cleaned_at timestamp )\nCREATE TABLE hospitality_technology.room_types ( room_type_id text PRIMARY KEY, property_id text, type_name text, description text, base_rate numeric, max_occupancy int, bed_type text, area_sqft numeric, amenities text )\nCREATE TABLE hospitality_technology.guests ( guest_id text PRIMARY KEY, first_name text, last_name text, email text, phone_number text, date_of_birth date, address_line1 text, city text, state_province text, postal_code text, country_code text, preferences text, loyalty_member_id text, communication_consent boolean, created_at timestamp, updated_at timestamp )\nCREATE TABLE hospitality_technology.reservations ( reservation_id text PRIMARY KEY, property_id text, guest_id text, room_id text, room_type_id text, check_in_date date, check_out_date date, actual_check_in_ts timestamp, actual_check_out_ts timestamp, num_adults int, num_children int, status text, booking_source text, rate_plan_id text, total_amount numeric, amount_paid numeric, special_requests text, created_at timestamp, updated_at timestamp )\nCREATE 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 )\nCREATE TABLE hospitality_technology.payments ( payment_id text PRIMARY KEY, reservation_id text, guest_id text, bill_id text, amount numeric, currency_code text, payment_method text, card_type text, card_last_four text, transaction_ref text, payment_timestamp timestamp, status text, staff_id_processed text, notes text )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Which citizens have made payments but have not uploaded any documents? Please show their first and last names and contact emails."}, {"role": "assistant", "content": "SELECT DISTINCT c.first_name, c.last_name, c.contact_email\nFROM government_services.citizens c\nJOIN government_services.payments p ON c.citizen_id = p.citizen_id\nWHERE c.citizen_id NOT IN (\n    SELECT d.citizen_id FROM government_services.documents d\n);"}, {"role": "user", "content": "Actually, do not include any citizens whose payments have a status other than 'Succeeded'."}, {"role": "assistant", "content": "SELECT DISTINCT c.first_name, c.last_name, c.contact_email\nFROM government_services.citizens c\nJOIN government_services.payments p ON c.citizen_id = p.citizen_id\nWHERE p.status = 'Succeeded'\nAND c.citizen_id NOT IN (\n    SELECT d.citizen_id FROM government_services.documents d\n);"}, {"role": "user", "content": "I got an error about duplicate emails. Can you remove duplicate citizens based only on their contact email?"}, {"role": "assistant", "content": "SELECT DISTINCT ON (c.contact_email) c.first_name, c.last_name, c.contact_email\nFROM government_services.citizens c\nJOIN government_services.payments p ON c.citizen_id = p.citizen_id\nWHERE p.status = 'Succeeded'\nAND c.citizen_id NOT IN (\n    SELECT d.citizen_id FROM government_services.documents d\n);"}, {"role": "user", "content": "Now, sort the result by first name ascending."}, {"role": "assistant", "content": "SELECT DISTINCT ON (c.contact_email) c.first_name, c.last_name, c.contact_email\nFROM government_services.citizens c\nJOIN government_services.payments p ON c.citizen_id = p.citizen_id\nWHERE p.status = 'Succeeded'\nAND c.citizen_id NOT IN (\n    SELECT d.citizen_id FROM government_services.documents d\n)\nORDER BY c.first_name ASC, c.contact_email;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens (\n    citizen_id character varying(64) NOT NULL,  -- unique identifier for the citizen\n    national_id_number character varying(128) NOT NULL UNIQUE, -- official national identification number\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    date_of_birth date NOT NULL,\n    gender character varying(20),\n    primary_address text NOT NULL, -- full primary residential address\n    contact_email character varying(128) UNIQUE,\n    contact_phone character varying(32),\n    registration_date timestamp NOT NULL, -- when the citizen profile was created\n    is_verified boolean DEFAULT false, -- whether identity has been officially verified\n    PRIMARY KEY (citizen_id)\n)\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE government_services.service_locations (\n    location_id character varying(64) NOT NULL, -- unique identifier for the physical location\n    agency_id character varying(64) NOT NULL, -- FK to agencies table\n    location_name character varying(200), -- e.g., Downtown DMV Office\n    address text NOT NULL,\n    city character varying(100),\n    state character varying(50),\n    postal_code character varying(20),\n    latitude numeric(9, 6),\n    longitude numeric(9, 6),\n    operating_hours text, -- description of opening times\n    contact_phone character varying(32),\n    is_accessible boolean, -- accessibility information (e.g., wheelchair access)\n    PRIMARY KEY (location_id)\n)\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Get a list of room types along with their property name and the count of rooms currently Available for each type."}, {"role": "assistant", "content": "SELECT rt.type_name, p.property_name, COUNT(r.room_id) AS available_rooms_count\nFROM hospitality_technology.room_types rt\nJOIN hospitality_technology.rooms r ON rt.room_type_id = r.room_type_id\n  AND r.status = 'Available'\nJOIN hospitality_technology.properties p ON rt.property_id = p.property_id\nGROUP BY rt.type_name, p.property_name;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties ( property_id character varying(64) NOT NULL, property_name character varying(255) NOT NULL, address_line1 character varying(255) NOT NULL, address_line2 character varying(255), city character varying(100) NOT NULL, state_province character varying(100), postal_code character varying(20) NOT NULL, country_code character varying(3) NOT NULL, phone_number character varying(30), email_address character varying(255), property_type character varying(50) NOT NULL, star_rating numeric(2,1), timezone character varying(64) NOT NULL, manager_staff_id character varying(64), created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (property_id) )\nCREATE TABLE hospitality_technology.rooms ( room_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, room_number character varying(10) NOT NULL, room_type_id character varying(64) NOT NULL, floor integer, status character varying(50) NOT NULL, is_smoking boolean NOT NULL DEFAULT false, features text, current_condition text, last_cleaned_at timestamp with time zone, PRIMARY KEY (room_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (room_type_id) REFERENCES hospitality_technology.room_types(room_type_id) )\nCREATE TABLE hospitality_technology.room_types ( room_type_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, type_name character varying(100) NOT NULL, description text, base_rate numeric(10, 2) NOT NULL, max_occupancy integer NOT NULL, bed_type character varying(50), area_sqft numeric(8,2), amenities text, PRIMARY KEY (room_type_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id) )\nCREATE TABLE hospitality_technology.guests ( guest_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, email character varying(255) UNIQUE, phone_number character varying(30), date_of_birth date, address_line1 character varying(255), city character varying(100), state_province character varying(100), postal_code character varying(20), country_code character varying(3), preferences text, loyalty_member_id character varying(64) UNIQUE, communication_consent boolean DEFAULT true, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (guest_id) )\nCREATE TABLE hospitality_technology.reservations ( reservation_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, guest_id character varying(64) NOT NULL, room_id character varying(64), room_type_id character varying(64) NOT NULL, check_in_date date NOT NULL, check_out_date date NOT NULL, actual_check_in_ts timestamp with time zone, actual_check_out_ts timestamp with time zone, num_adults integer NOT NULL, num_children integer DEFAULT 0, status character varying(50) NOT NULL, booking_source character varying(100), rate_plan_id character varying(64), total_amount numeric(12, 2), amount_paid numeric(12, 2) DEFAULT 0.00, special_requests text, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (reservation_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (room_id) REFERENCES hospitality_technology.rooms(room_id), FOREIGN KEY (room_type_id) REFERENCES hospitality_technology.room_types(room_type_id) )\nCREATE TABLE hospitality_technology.staff ( staff_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, position character varying(100) NOT NULL, work_email character varying(255) UNIQUE, work_phone character varying(30), hire_date date NOT NULL, termination_date date, is_active boolean NOT NULL DEFAULT true, access_level integer NOT NULL, manager_id character varying(64), created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (staff_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (manager_id) REFERENCES hospitality_technology.staff(staff_id) )\nCREATE 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) )\nCREATE TABLE hospitality_technology.service_orders ( order_id character varying(64) NOT NULL, reservation_id character varying(64), guest_id character varying(64) NOT NULL, service_id character varying(64) NOT NULL, staff_id_ordered character varying(64), staff_id_delivered character varying(64), order_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, delivery_timestamp timestamp with time zone, quantity integer NOT NULL DEFAULT 1, unit_price numeric(10, 2) NOT NULL, total_price numeric(12, 2) NOT NULL, status character varying(50) NOT NULL, notes text, bill_id character varying(64), PRIMARY KEY (order_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (service_id) REFERENCES hospitality_technology.services(service_id), FOREIGN KEY (staff_id_ordered) REFERENCES hospitality_technology.staff(staff_id), FOREIGN KEY (staff_id_delivered) REFERENCES hospitality_technology.staff(staff_id) )\nCREATE TABLE hospitality_technology.reviews ( review_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, reservation_id character varying(64) UNIQUE, guest_id character varying(64) NOT NULL, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source character varying(100), review_date timestamp with time zone NOT NULL DEFAULT current_timestamp, is_public boolean DEFAULT true, staff_response text, response_staff_id character varying(64), response_date timestamp with time zone, PRIMARY KEY (review_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (response_staff_id) REFERENCES hospitality_technology.staff(staff_id) )\n"}
{"conversations": [{"role": "user", "content": "List all wallets that were created during the hour of the day which saw the highest number of wallet creations. Show the wallet ID, user ID, address, and creation timestamp."}, {"role": "assistant", "content": "WITH HourlyCounts AS (\n    SELECT EXTRACT(HOUR FROM created_at) AS hour, COUNT(*) AS wallet_count\n    FROM web3.wallets\n    GROUP BY 1\n),\nMaxHour AS (\n    SELECT hour\n    FROM HourlyCounts\n    ORDER BY wallet_count DESC\n    LIMIT 1\n)\nSELECT wallet_id, user_id, address, created_at\nFROM web3.wallets\nWHERE EXTRACT(HOUR FROM created_at) = (SELECT hour FROM MaxHour);"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.wallets ( wallet_id text PRIMARY KEY, user_id text, address text, private_key text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "What is the fuel consumption rate of train number T1234?"}, {"role": "assistant", "content": "I'm sorry, but I don't have information on the fuel consumption rate of train number T1234. The data available in the system only includes details such as train ID, model, manufacturer, year manufactured, capacity, status, and maintenance dates."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.trains ( train_id character varying(64) NOT NULL, train_number character varying(32) NOT NULL, model character varying(128), manufacturer character varying(128), year_manufactured integer, capacity integer NOT NULL, status character varying(32) NOT NULL DEFAULT 'Active', last_maintenance_date date, next_maintenance_date date, PRIMARY KEY (train_id), UNIQUE (train_number) )\n"}
{"conversations": [{"role": "user", "content": "Count the total number of unique insurance providers in the system."}, {"role": "assistant", "content": "SELECT COUNT(DISTINCT insurance_provider) FROM healthcare.insurance_plans;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )\n"}
{"conversations": [{"role": "user", "content": "Show me the top 5 NFT collections with the highest token count on Ethereum, along with their names, symbols, and floor prices."}, {"role": "assistant", "content": "SELECT n.name, n.symbol, n.floor_price, n.token_count FROM nft_collections n WHERE n.blockchain = 'ethereum' ORDER BY n.token_count DESC LIMIT 5;"}, {"role": "user", "content": "Now, join this with the nft_metadata table to include the average rarity score for each collection."}, {"role": "assistant", "content": "SELECT n.name, n.symbol, n.floor_price, n.token_count, AVG(m.rarity_score) as avg_rarity_score FROM nft_collections n JOIN nft_metadata m ON n.contract_address = m.contract_address WHERE n.blockchain = 'ethereum' GROUP BY n.name, n.symbol, n.floor_price, n.token_count ORDER BY n.token_count DESC LIMIT 5;"}, {"role": "user", "content": "Can you filter these results to only show collections with an average rarity score greater than 80?"}, {"role": "assistant", "content": "SELECT n.name, n.symbol, n.floor_price, n.token_count, AVG(m.rarity_score) as avg_rarity_score FROM nft_collections n JOIN nft_metadata m ON n.contract_address = m.contract_address WHERE n.blockchain = 'ethereum' GROUP BY n.name, n.symbol, n.floor_price, n.token_count HAVING AVG(m.rarity_score) > 80 ORDER BY n.token_count DESC LIMIT 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE erc1155_approval_for_all ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash text, log_index integer, contract_address text )\nCREATE TABLE erc20_balances ( block_number bigint, contract_address text, wallet_address text, amount text, pk text )\nCREATE TABLE sui_coins ( object_id text, status text, coin_type text, balance text, owner text )\nCREATE TABLE sui_coins_metadata ( object_id text, coin_type text, status text, decimals bigint, description text, icon_url text, symbol text, name text )\nCREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE token_prices_latest ( blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\nCREATE TABLE token_info ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, tick text, max_supply decimal, lim decimal, wlim decimal, dec integer, creator text )\nCREATE 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 )\nCREATE TABLE mud_holesky_redstone ( address text, table_id text, key_bytes text, key0 text, key1 text, static_data text, encoded_lengths text, dynamic_data text, is_deleted boolean, block_number bigint, log_index bigint )\nCREATE TABLE token_balances_bitcoin ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply text, amount text )\nCREATE 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 )\nCREATE TABLE token_balances_avalanche ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "For each group chat, list its ID, name, creation time, and the creation time of the next group chat created after it, ordered by creation time."}, {"role": "assistant", "content": "SELECT conversation_id, group_name, created_at, LEAD(created_at) OVER (ORDER BY created_at) AS next_group_chat_created_at FROM social_media.conversations WHERE is_group_chat = true ORDER BY created_at;"}, {"role": "user", "content": "Only show pairs where the next group chat was created within 48 hours of the current one, and also include the time difference in hours."}, {"role": "assistant", "content": "WITH RankedGroupChats AS ( SELECT conversation_id, group_name, created_at, LEAD(created_at) OVER (ORDER BY created_at) AS next_group_chat_created_at FROM social_media.conversations WHERE is_group_chat = true ) SELECT conversation_id, group_name, created_at, next_group_chat_created_at, EXTRACT(EPOCH FROM (next_group_chat_created_at - created_at)) / 3600 AS time_difference_hours FROM RankedGroupChats WHERE next_group_chat_created_at IS NOT NULL AND EXTRACT(EPOCH FROM (next_group_chat_created_at - created_at)) <= 48 * 3600 ORDER BY created_at;"}, {"role": "user", "content": "Further refine: Only include group chats whose names contain 'Discuss'."}, {"role": "assistant", "content": "WITH RankedGroupChats AS ( SELECT conversation_id, group_name, created_at, LEAD(created_at) OVER (ORDER BY created_at) AS next_group_chat_created_at FROM social_media.conversations WHERE is_group_chat = true ) SELECT conversation_id, group_name, created_at, next_group_chat_created_at, EXTRACT(EPOCH FROM (next_group_chat_created_at - created_at)) / 3600 AS time_difference_hours FROM RankedGroupChats WHERE next_group_chat_created_at IS NOT NULL AND EXTRACT(EPOCH FROM (next_group_chat_created_at - created_at)) <= 48 * 3600 AND group_name LIKE '%Discuss%' ORDER BY created_at;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE social_media.conversations ( conversation_id character varying(64) NOT NULL, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, last_message_at timestamp, is_group_chat boolean NOT NULL DEFAULT false, group_name character varying(100), PRIMARY KEY (conversation_id) )\n"}
{"conversations": [{"role": "user", "content": "Show the symbol, name, and total supply for all SUI coins with status 'active'."}, {"role": "assistant", "content": "SELECT scm.symbol, scm.name, scm.coin_type, scm.total_supply\nFROM sui_coins_metadata scm\nWHERE scm.status = 'active';"}, {"role": "user", "content": "I received an error that column 'total_supply' doesn't exist in sui_coins_metadata."}, {"role": "assistant", "content": "SELECT scm.symbol, scm.name, scm.coin_type\nFROM sui_coins_metadata scm\nWHERE scm.status = 'active';"}, {"role": "user", "content": "Now, join with sui_coins to add up the total balance across all owners for each coin_type."}, {"role": "assistant", "content": "SELECT scm.symbol, scm.name, scm.coin_type, SUM(CAST(sc.balance AS NUMERIC)) AS total_balance\nFROM sui_coins_metadata scm\nJOIN sui_coins sc ON scm.coin_type = sc.coin_type\nWHERE scm.status = 'active'\nGROUP BY scm.symbol, scm.name, scm.coin_type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE erc1155_approval_for_all ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash text, log_index integer, contract_address text )\nCREATE TABLE erc20_balances ( block_number bigint, contract_address text, wallet_address text, amount text, pk text )\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address text, wallet_address text, amount text, pk integer )\nCREATE TABLE nft_holders ( block_number bigint, contract_address text, wallet_address text, token_id text, contract_type text, amount text, pk text )\nCREATE TABLE nft_holder_historical ( block_number bigint, contract_address text, wallet_address text, token_id text, contract_type text, amount text, pk integer )\nCREATE TABLE sui_coins ( object_id text, status text, coin_type text, balance text, owner text )\nCREATE TABLE sui_coins_metadata ( object_id text, coin_type text, status text, decimals bigint, description text, icon_url text, symbol text, name text )\nCREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE token_prices_latest ( blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash text, log_index integer, contract_address text, pk integer )\nCREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\nCREATE TABLE token_info ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, tick text, max_supply decimal, lim decimal, wlim decimal, dec integer, creator text )\nCREATE 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 )\nCREATE TABLE mud_holesky_redstone ( address text, table_id text, key_bytes text, key0 text, key1 text, static_data text, encoded_lengths text, dynamic_data text, is_deleted boolean, block_number bigint, log_index bigint )\nCREATE TABLE token_balances_bitcoin ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply text, amount text )\nCREATE 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 )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, log_index integer, type text, tick text, id text, amt decimal, from_address text, to_address text )\nCREATE 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 )\nCREATE TABLE token_balances_avalanche ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\n"}
{"conversations": [{"role": "user", "content": "List all users whose email contains the word 'block', along with their username and registration timestamp."}, {"role": "assistant", "content": "SELECT user_id, username, email, created_at\nFROM web3.users\nWHERE email ILIKE '%block%';"}, {"role": "user", "content": "Can you also include the total number of such users in the result?"}, {"role": "assistant", "content": "SELECT user_id, username, email, created_at, COUNT(*) OVER() AS total_matching_users\nFROM web3.users\nWHERE email ILIKE '%block%';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.users ( user_id text, username text, email text, password_hash text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "For the 'DeFi' narrative, what is the average ROI and the total net inflow (usd_value where type=1) from smart money token inflow?"}, {"role": "assistant", "content": "SELECT AVG(sm.roi) AS avg_roi, SUM(smt.usd_value) AS total_net_inflow\nFROM smart_money_token_inflow smt\nJOIN smart_money_profit sm ON smt.chain = sm.chain\nWHERE smt.narrative = 'DeFi' AND smt.type = 1;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE narrative_info ( narrative text, top_3_coins text, price_change_percentage_1h numeric, price_change_percentage_24h numeric, price_change_percentage_7d numeric, market_cap numeric, volume_24h numeric, trend_rank numeric, token_num numeric )\nCREATE 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 )\nCREATE TABLE smart_money_profit ( address text, rank numeric, profit numeric, roi numeric, realized_ratio numeric, most_profit_token text, last_trade_time text, chain text )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List the top 3 tokens by net flow on the Binance chain, including their symbol and average cost."}, {"role": "assistant", "content": "SELECT token_symbol, net_flow, avg_cost FROM smart_money_token_performance WHERE chain = 'Binance' ORDER BY net_flow DESC LIMIT 3;"}, {"role": "user", "content": "Actually, I want to see tokens with a positive net flow and ROI above 20%."}, {"role": "assistant", "content": "SELECT token_symbol, net_flow, avg_cost FROM smart_money_token_performance WHERE chain = 'Binance' AND net_flow > 0 AND roi > 20 ORDER BY net_flow DESC LIMIT 3;"}, {"role": "user", "content": "Can you also include the current price and order by ROI instead?"}, {"role": "assistant", "content": "SELECT token_symbol, net_flow, avg_cost, price FROM smart_money_token_performance WHERE chain = 'Binance' AND net_flow > 0 AND roi > 20 ORDER BY roi DESC LIMIT 3;"}, {"role": "user", "content": "Now filter these results to only include tokens with a price above $1."}, {"role": "assistant", "content": "SELECT token_symbol, net_flow, avg_cost, price FROM smart_money_token_performance WHERE chain = 'Binance' AND net_flow > 0 AND roi > 20 AND price > 1 ORDER BY roi DESC LIMIT 3;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE smart_money_token_performance ( token_address character varying(100) NOT NULL, -- the token's address token_symbol character varying(100), -- the tokens's symbol pnl numeric(38,2), -- the profit users made on this token net_flow numeric(38,2), -- the netflow of the token, means the money user spent minus the the money user sold of this token avg_cost numeric(38,16), -- the average cost price of user spent on this token price double precision, -- the current price of the token realized_ratio numeric(10,2), -- the ratio user sold of the token roi numeric(10,2), -- the roi users made of this token chain character varying(100), -- the chain that the token resides PRIMARY KEY (token_address, chain) )\n"}
{"conversations": [{"role": "user", "content": "For each claim, show the claim ID, policy ID, and the product name of the insurance product that applies to the policy."}, {"role": "assistant", "content": "SELECT c.claim_id, c.policy_id, ip.product_name FROM insurance.claims c JOIN insurance.insurance_products ip ON c.policy_id = ip.product_id;"}, {"role": "user", "content": "Wait, the policy_id and product_id are different things. Can you instead show, for each claim, the claim ID and incident date, along with the name and type of the insurance product if the policy is of the same id as product_id?"}, {"role": "assistant", "content": "SELECT c.claim_id, c.incident_date, ip.product_name, ip.product_type FROM insurance.claims c JOIN insurance.insurance_products ip ON c.policy_id = ip.product_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Can you show me all achievement unlock records where the same player unlocked two different achievements within the same day? Please show player_id, achievement_id_1, achievement_id_2, and the unlock dates for each."}, {"role": "assistant", "content": "SELECT pa1.player_id, pa1.achievement_id as achievement_id_1, pa2.achievement_id as achievement_id_2, pa1.unlocked_at as unlock_date_1, pa2.unlocked_at as unlock_date_2\nFROM gaming_technology.player_achievements pa1\nJOIN gaming_technology.player_achievements pa2\n  ON pa1.player_id = pa2.player_id\n  AND pa1.achievement_id <> pa2.achievement_id\n  AND DATE(pa1.unlocked_at) = DATE(pa2.unlocked_at)\n  AND pa1.unlocked_at < pa2.unlocked_at;"}, {"role": "user", "content": "Add a condition to only include records where both achievements were unlocked on or after January 1st, 2024."}, {"role": "assistant", "content": "SELECT pa1.player_id, pa1.achievement_id as achievement_id_1, pa2.achievement_id as achievement_id_2, pa1.unlocked_at as unlock_date_1, pa2.unlocked_at as unlock_date_2\nFROM gaming_technology.player_achievements pa1\nJOIN gaming_technology.player_achievements pa2\n  ON pa1.player_id = pa2.player_id\n  AND pa1.achievement_id <> pa2.achievement_id\n  AND DATE(pa1.unlocked_at) = DATE(pa2.unlocked_at)\n  AND pa1.unlocked_at < pa2.unlocked_at\nWHERE pa1.unlocked_at >= '2024-01-01' AND pa2.unlocked_at >= '2024-01-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.player_achievements ( player_achievement_id uuid, player_id uuid, achievement_id uuid, unlocked_at timestamp with time zone )\n"}
{"conversations": [{"role": "user", "content": "List all loans (loan_id, loan_type, principal_amount) that have a current principal balance less than 25% of the original principal amount, along with their account_id and the difference between principal_amount and current_principal_balance."}, {"role": "assistant", "content": "SELECT loan_id, loan_type, principal_amount, account_id, (principal_amount - current_principal_balance) AS amount_paid FROM financial_services.loans WHERE current_principal_balance < (0.25 * principal_amount);"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE financial_services.loans ( loan_id text, account_id text, loan_type text, principal_amount numeric, current_principal_balance numeric, interest_rate numeric, term_months integer, origination_date date, maturity_date date, monthly_payment numeric, collateral_description text, status text )\n"}
{"conversations": [{"role": "user", "content": "How many participants are there in each conversation? Return conversation_id and participant_count."}, {"role": "assistant", "content": "SELECT conversation_id,\n       COUNT(*) AS participant_count\nFROM social_media.conversation_participants\nGROUP BY conversation_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE social_media.conversation_participants ( participant_id text, conversation_id text, user_id text, joined_at timestamp, last_read_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "For each event recorded, list its ID, name, and the status and value of the transaction in which it occurred."}, {"role": "assistant", "content": "SELECT E.event_id, E.event_name, E.transaction_id, T.status, T.value FROM web3.events AS E JOIN web3.transactions AS T ON E.transaction_id = T.transaction_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.events (\n    event_id character varying(64) NOT NULL,  -- unique identifier for the event\n    contract_id character varying(64) NOT NULL, -- identifier of the contract emitting the event\n    event_name character varying(128) NOT NULL, -- name of the event\n    data text NOT NULL, -- data payload of the event\n    emitted_at timestamp NOT NULL, -- time when the event was emitted\n    transaction_id character varying(64) NOT NULL, -- identifier of the transaction that triggered the event\n    log_index integer NOT NULL, -- index of the event log in the transaction\n    PRIMARY KEY (event_id)\n)\nCREATE TABLE web3.transactions ( transaction_id character varying(64) NOT NULL, from_address character varying(128) NOT NULL, to_address character varying(128), value numeric(38,14) NOT NULL, gas_used integer NOT NULL, gas_price numeric(38,14) NOT NULL, block_number integer NOT NULL, timestamp timestamp NOT NULL, input_data text, status character varying(32) NOT NULL, nonce integer NOT NULL, PRIMARY KEY (transaction_id) )\nCREATE TABLE web3.tokens ( token_id text PRIMARY KEY, contract_address text, token_name text, token_symbol text, decimals int, total_supply numeric )\nCREATE TABLE web3.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )\nCREATE TABLE web3.users ( user_id text, username text, email text, password_hash text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Which route numbers connect locations with a distance less than 80 km and more than 5 words in their description? Include the route type in the results."}, {"role": "assistant", "content": "SELECT route_number, type FROM transportation.routes WHERE distance_km < 80 AND array_length(regexp_split_to_array(description, '\\s+'), 1) > 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.routes ( route_id text, route_number text, description text, origin_location_id text, destination_location_id text, distance_km numeric, estimated_duration_minutes integer, type text )\n"}
{"conversations": [{"role": "user", "content": "Retrieve the vehicle_id, make, model, and the next_service_due_date for each vehicle based on the most recent maintenance log."}, {"role": "assistant", "content": "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;"}, {"role": "user", "content": "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."}, {"role": "assistant", "content": "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 SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "I want to list all employees who currently manage at least one other employee, showing their full name, email, and the total number of direct reports for each manager."}, {"role": "assistant", "content": "SELECT e.employee_id, e.first_name || ' ' || e.last_name AS manager_full_name, e.email, COUNT(r.employee_id) AS direct_report_count\nFROM financial_services.employees e\nJOIN financial_services.employees r ON e.employee_id = r.manager_id\nWHERE e.status = 'Active'\nGROUP BY e.employee_id, e.first_name, e.last_name, e.email;"}, {"role": "user", "content": "Can you also include the job_title and department of each manager in the result?"}, {"role": "assistant", "content": "SELECT e.employee_id, e.first_name || ' ' || e.last_name AS manager_full_name, e.email, e.job_title, e.department, COUNT(r.employee_id) AS direct_report_count\nFROM financial_services.employees e\nJOIN financial_services.employees r ON e.employee_id = r.manager_id\nWHERE e.status = 'Active'\nGROUP BY e.employee_id, e.first_name, e.last_name, e.email, e.job_title, e.department;"}, {"role": "user", "content": "I noticed some managers don't have any reports—that shouldn't be the case. Only show managers who have at least two direct reports."}, {"role": "assistant", "content": "SELECT e.employee_id, e.first_name || ' ' || e.last_name AS manager_full_name, e.email, e.job_title, e.department, COUNT(r.employee_id) AS direct_report_count\nFROM financial_services.employees e\nJOIN financial_services.employees r ON e.employee_id = r.manager_id\nWHERE e.status = 'Active'\nGROUP BY e.employee_id, e.first_name, e.last_name, e.email, e.job_title, e.department\nHAVING COUNT(r.employee_id) >= 2;"}, {"role": "user", "content": "Please order the output by the number of direct reports in descending order."}, {"role": "assistant", "content": "SELECT e.employee_id, e.first_name || ' ' || e.last_name AS manager_full_name, e.email, e.job_title, e.department, COUNT(r.employee_id) AS direct_report_count\nFROM financial_services.employees e\nJOIN financial_services.employees r ON e.employee_id = r.manager_id\nWHERE e.status = 'Active'\nGROUP BY e.employee_id, e.first_name, e.last_name, e.email, e.job_title, e.department\nHAVING COUNT(r.employee_id) >= 2\nORDER BY direct_report_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE financial_services.accounts (\n    account_id character varying(64) NOT NULL, -- unique identifier for the account\n    customer_id character varying(64) NOT NULL, -- foreign key linking to the customer\n    account_number character varying(128) NOT NULL UNIQUE, -- unique account number visible to customer\n    account_type character varying(50) NOT NULL, -- e.g., Checking, Savings, Investment, Loan, Credit Card\n    balance numeric(19, 4) NOT NULL DEFAULT 0.00, -- current account balance\n    currency character varying(3) NOT NULL, -- currency code (e.g., USD, EUR)\n    opened_date date NOT NULL, -- date the account was opened\n    status character varying(32) NOT NULL, -- e.g., Open, Closed, Frozen\n    interest_rate numeric(5, 4), -- annual interest rate, if applicable\n    last_updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last account update\n    PRIMARY KEY (account_id),\n    FOREIGN KEY (customer_id) REFERENCES financial_services.customers(customer_id)\n)\nCREATE TABLE financial_services.transactions (\n    transaction_id character varying(64) NOT NULL, -- unique identifier for the transaction\n    account_id character varying(64) NOT NULL, -- account involved in the transaction\n    related_account_id character varying(64), -- counterpart account for transfers\n    transaction_type character varying(50) NOT NULL, -- e.g., Deposit, Withdrawal, Transfer, Payment, Fee, Interest\n    amount numeric(19, 4) NOT NULL, -- transaction amount\n    currency character varying(3) NOT NULL, -- transaction currency\n    transaction_date timestamp NOT NULL, -- exact time of the transaction\n    effective_date date NOT NULL, -- date the transaction affects the balance\n    description text, -- description or memo of the transaction\n    status character varying(32) NOT NULL, -- e.g., Pending, Completed, Failed, Reversed\n    reference_number character varying(128), -- external reference if applicable (e.g., check number)\n    PRIMARY KEY (transaction_id),\n    FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id),\n    FOREIGN KEY (related_account_id) REFERENCES financial_services.accounts(account_id)\n)\nCREATE TABLE financial_services.employees (\n    employee_id character varying(64) NOT NULL,  -- unique identifier for the employee\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    job_title character varying(100) NOT NULL, -- e.g., Teller, Branch Manager, Financial Advisor, Analyst\n    department character varying(100), -- e.g., Retail Banking, Wealth Management, IT\n    branch_id character varying(64), -- Identifier for the branch they work at (if applicable)\n    email character varying(128) NOT NULL UNIQUE,\n    phone_extension character varying(20),\n    hire_date date NOT NULL,\n    termination_date date, -- Date of termination, null if currently employed\n    manager_id character varying(64), -- Self-referencing key for manager relationship\n    status character varying(32) NOT NULL, -- e.g., Active, Terminated, On Leave\n    PRIMARY KEY (employee_id),\n    FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), -- Assuming a branches table exists\n    FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all room types and available services for each property, showing the property ID, room type name, base rate, service name, and service price."}, {"role": "assistant", "content": "SELECT T1.property_id ,  T1.type_name ,  T1.base_rate ,  T2.service_name ,  T2.price FROM hospitality_technology.room_types AS T1 INNER JOIN hospitality_technology.services AS T2 ON T1.property_id  =  T2.property_id WHERE T2.is_available  =  true"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.room_types ( room_type_id text, property_id text, type_name text, description text, base_rate numeric, max_occupancy integer, bed_type text, area_sqft numeric, amenities text )\nCREATE TABLE hospitality_technology.services (\n    service_id character varying(64) NOT NULL, -- unique identifier for a chargeable service\n    property_id character varying(64) NOT NULL, -- FK to properties table\n    service_name character varying(150) NOT NULL, -- e.g., Room Service - Burger, Spa - Massage 60min, Laundry - Shirt\n    description text,\n    category character varying(100), -- e.g., Food & Beverage, Wellness, Business Center, Activities\n    price numeric(10, 2) NOT NULL, -- price per unit/instance\n    unit character varying(30), -- e.g., Per Item, Per Hour, Per Day\n    is_available boolean NOT NULL DEFAULT true, -- is the service currently offered?\n    department character varying(100), -- department responsible (e.g., F&B, Spa, Housekeeping)\n    PRIMARY KEY (service_id),\n    FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id)\n)\n"}
{"conversations": [{"role": "user", "content": "How many unique IP addresses are there in the nodes table?"}, {"role": "assistant", "content": "SELECT COUNT(DISTINCT ip_address) FROM blockchain.nodes;"}, {"role": "user", "content": "Can you break this down by port numbers, showing the count of nodes for each port?"}, {"role": "assistant", "content": "SELECT port, COUNT(node_id) as node_count FROM blockchain.nodes GROUP BY port;"}, {"role": "user", "content": "Now, order these results by node_count in descending order."}, {"role": "assistant", "content": "SELECT port, COUNT(node_id) as node_count FROM blockchain.nodes GROUP BY port ORDER BY node_count DESC;"}, {"role": "user", "content": "Actually, I only want to see ports that have more than 5 nodes."}, {"role": "assistant", "content": "SELECT port, COUNT(node_id) as node_count FROM blockchain.nodes GROUP BY port HAVING COUNT(node_id) > 5 ORDER BY node_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE blockchain.nodes ( node_id text PRIMARY KEY, ip_address text, port int, last_seen timestamp )\n"}
{"conversations": [{"role": "user", "content": "List all patients who have insurance plans with group numbers, showing their patient IDs and the count of such plans per patient."}, {"role": "assistant", "content": "SELECT patient_id, COUNT(*) AS plan_count FROM healthcare.patient_insurance WHERE group_number IS NOT NULL GROUP BY patient_id;"}, {"role": "user", "content": "Actually, I only need patients who have more than 2 such plans."}, {"role": "assistant", "content": "SELECT patient_id, COUNT(*) AS plan_count FROM healthcare.patient_insurance WHERE group_number IS NOT NULL GROUP BY patient_id HAVING COUNT(*) > 2;"}, {"role": "user", "content": "Can you also include the earliest effective date among these plans for each patient?"}, {"role": "assistant", "content": "SELECT patient_id, COUNT(*) AS plan_count, MIN(effective_date) AS earliest_effective_date FROM healthcare.patient_insurance WHERE group_number IS NOT NULL GROUP BY patient_id HAVING COUNT(*) > 2;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.patient_insurance (\n    patient_insurance_id character varying(64) NOT NULL, -- unique identifier for this patient-plan link\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    plan_id character varying(64) NOT NULL, -- FK to insurance_plans table\n    policy_number character varying(100) NOT NULL, -- patient's policy number\n    group_number character varying(100), -- group number, if applicable\n    subscriber_name character varying(200), -- name of the primary policy holder\n    effective_date date NOT NULL, -- date the coverage begins\n    expiration_date date, -- date the coverage ends (if known)\n    is_primary boolean NOT NULL DEFAULT true, -- indicates if this is the primary insurance\n    PRIMARY KEY (patient_insurance_id),\n    UNIQUE (patient_id, plan_id, policy_number) -- ensure a patient doesn't have the same policy twice\n)\n"}
{"conversations": [{"role": "user", "content": "Find all medical records where the vitals field indicates a heart rate over 100 bpm, along with the associated appointment details and diagnosis description if available."}, {"role": "assistant", "content": "SELECT mr.record_id, mr.patient_id, a.appointment_time, a.doctor_id, a.reason, d.description FROM healthcare.medical_records mr LEFT JOIN healthcare.appointments a ON mr.appointment_id = a.appointment_id LEFT JOIN healthcare.diagnoses d ON mr.record_id = d.record_id WHERE mr.vitals::json->>'heart_rate' > '100';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.appointments ( appointment_id text, patient_id text, doctor_id text, appointment_time timestamp, duration_minutes integer, reason text, status text, location_id text, notes text, created_at timestamp )\nCREATE 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 )\nCREATE TABLE healthcare.diagnoses ( diagnosis_id text, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )\n"}
{"conversations": [{"role": "user", "content": "Show a list of all fuel refueling events for each trip, including the trip ID, fuel type, quantity, total cost, and the name of the refueling location."}, {"role": "assistant", "content": "SELECT fl.trip_id, fl.fuel_type, fl.quantity, fl.total_cost, l.name AS location_name\nFROM transportation.fuel_logs fl\nJOIN transportation.locations l ON fl.location_id = l.location_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.vehicles ( vehicle_id text, license_plate text, vin text, make text, model text, year integer, type text, capacity integer, fuel_type text, status text, depot_id text, acquisition_date date )\nCREATE TABLE transportation.drivers ( driver_id text, 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 )\nCREATE TABLE transportation.routes ( route_id text, route_number text, description text, origin_location_id text, destination_location_id text, distance_km numeric, estimated_duration_minutes integer, type text )\nCREATE TABLE transportation.trips ( trip_id text, route_id text, vehicle_id text, driver_id text, scheduled_departure timestamp, actual_departure timestamp, scheduled_arrival timestamp, actual_arrival timestamp, origin_location_id text, destination_location_id text, status text, passenger_count integer, cargo_manifest_id text )\nCREATE TABLE transportation.locations ( location_id text, name text, type text, address_line1 text, city text, state_province text, postal_code text, country text, latitude numeric, longitude numeric, timezone text )\nCREATE TABLE transportation.maintenance_logs ( log_id text, vehicle_id text, service_date date, odometer_reading integer, service_type text, description text, cost numeric, mechanic_name text, next_service_due_date date )\nCREATE TABLE transportation.fuel_logs ( fuel_log_id text, vehicle_id text, trip_id text, log_timestamp timestamp, fuel_type text, quantity numeric, unit text, cost_per_unit numeric, total_cost numeric, odometer_reading integer, location_id text )\nCREATE TABLE transportation.passengers ( passenger_id text, first_name text, last_name text, email text, phone_number text, date_of_birth date, loyalty_program_id text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List the plan_id, plan_name, and plan_type for all insurance plans where the insurance_provider is 'Humana'."}, {"role": "assistant", "content": "SELECT\n  plan_id,\n  plan_name,\n  plan_type\nFROM healthcare.insurance_plans\nWHERE\n  insurance_provider = 'Humana';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.patients ( patient_id text, 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 )\nCREATE TABLE healthcare.appointments (\n    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    doctor_id character varying(64) NOT NULL, -- FK to doctors table\n    appointment_time timestamp with time zone NOT NULL, -- date and time of the appointment\n    duration_minutes integer NOT NULL, -- expected duration in minutes\n    reason text, -- reason for the visit\n    status character varying(32) NOT NULL, -- e.g., Scheduled, Completed, Cancelled, No-show\n    location_id character varying(64), -- FK to a potential locations/clinics table\n    notes text, -- notes related to scheduling\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (appointment_id)\n)\nCREATE TABLE healthcare.medical_records (\n    record_id character varying(64) NOT NULL,  -- unique identifier for the medical record entry\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    appointment_id character varying(64) UNIQUE, -- FK to appointments table (can be null if record not tied to specific appt)\n    doctor_id character varying(64) NOT NULL, -- FK to doctors table (doctor creating the record)\n    record_date timestamp with time zone NOT NULL, -- date the record/observation was made\n    chief_complaint text, -- patient's primary reason for visit\n    present_illness_history text, -- detailed history of the current issue\n    past_medical_history text, -- relevant past conditions/surgeries\n    physical_examination_notes text, -- findings from the physical exam\n    assessment text, -- doctor's assessment/diagnosis summary\n    treatment_plan text, -- planned course of action\n    vitals jsonb, -- store vitals like BP, HR, Temp as structured JSON\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (record_id)\n)\nCREATE TABLE healthcare.diagnoses ( diagnosis_id.text, record_id.text, patient_id.text, doctor_id.text, diagnosis_code.text, code_type.text, description.text, diagnosis_date.date, status.text, is_chronic.boolean )\nCREATE TABLE healthcare.medications ( medication_id text PRIMARY KEY, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )\nCREATE TABLE healthcare.prescriptions ( prescription_id character varying(64) NOT NULL, record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, medication_id character varying(64) NOT NULL, dosage character varying(100) NOT NULL, frequency character varying(100) NOT NULL, route character varying(50), start_date date NOT NULL, end_date date, quantity_dispensed numeric(10,2), refills_allowed integer NOT NULL DEFAULT 0, prescription_date timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (prescription_id) )\nCREATE TABLE healthcare.insurance_plans (\n    plan_id character varying(64) NOT NULL, -- unique identifier for the insurance plan\n    plan_name character varying(200) NOT NULL, -- name of the insurance plan\n    insurance_provider character varying(100) NOT NULL, -- name of the insurance company\n    plan_type character varying(50), -- e.g., PPO, HMO, EPO\n    contact_phone character varying(20), -- provider contact number\n    website character varying(255), -- provider website\n    PRIMARY KEY (plan_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Count the number of policies issued in each calendar year, and show the year and the count."}, {"role": "assistant", "content": "SELECT EXTRACT(YEAR FROM issued_at), COUNT(*) FROM insurance.policies WHERE issued_at IS NOT NULL GROUP BY 1 ORDER BY 1;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.customers ( customer_id text, first_name text, last_name text, date_of_birth date, ssn_hash text, address_line1 text, address_line2 text, city text, state text, zip_code text, country text, phone_number text, email text, created_at timestamp, updated_at timestamp, status text )\nCREATE 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 )\nCREATE TABLE insurance.insurance_products ( product_id text, 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 )\nCREATE TABLE insurance.agents ( agent_id text, 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "What is the current operational status of the train car with car_id 'CAR123'?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information on the current operational status of the train car with car_id 'CAR123'. The data in the train_cars table does not include real-time status updates or operational conditions."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.train_cars ( car_id text PRIMARY KEY, train_id text, car_number text, car_type text, class text, capacity int, features text )\n"}
{"conversations": [{"role": "user", "content": "List the names of active services and their categories provided by agencies with a 'Federal' jurisdiction level."}, {"role": "assistant", "content": "SELECT T1.service_name, T1.category FROM government_services.services AS T1 JOIN government_services.agencies AS T2 ON T1.agency_id = T2.agency_id WHERE T1.is_active = TRUE AND T2.jurisdiction_level = 'Federal';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens (\n    citizen_id character varying(64) NOT NULL,  -- unique identifier for the citizen\n    national_id_number character varying(128) NOT NULL UNIQUE, -- official national identification number\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    date_of_birth date NOT NULL,\n    gender character varying(20),\n    primary_address text NOT NULL, -- full primary residential address\n    contact_email character varying(128) UNIQUE,\n    contact_phone character varying(32),\n    registration_date timestamp NOT NULL, -- when the citizen profile was created\n    is_verified boolean DEFAULT false, -- whether identity has been officially verified\n    PRIMARY KEY (citizen_id)\n)\nCREATE 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 )\nCREATE TABLE government_services.services ( service_id character varying(64) NOT NULL, agency_id character varying(64) NOT NULL, service_name character varying(255) NOT NULL, description text, category character varying(100), eligibility_criteria text, standard_fee numeric(10, 2) DEFAULT 0.00, average_processing_time_days integer, is_active boolean DEFAULT true, online_application_url character varying(255), PRIMARY KEY (service_id) )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE government_services.notifications ( notification_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, application_id character varying(64), message_subject character varying(255), message_body text NOT NULL, channel character varying(30) NOT NULL, sent_at timestamp NOT NULL, status character varying(30) NOT NULL, related_entity_type character varying(50), related_entity_id character varying(64), PRIMARY KEY (notification_id) )\n"}
{"conversations": [{"role": "user", "content": "List each lawyer's full name with the full name of the partner at the same firm."}, {"role": "assistant", "content": "SELECT l.lawyer_id,\n       CONCAT(l.first_name, ' ', l.last_name) AS lawyer_name,\n       CONCAT(p.first_name, ' ', p.last_name) AS partner_name\nFROM legal_services.lawyers l\nJOIN legal_services.lawyers p\n  ON l.firm_id = p.firm_id\n AND p.is_partner = true;"}, {"role": "user", "content": "Actually, I only want those lawyers whose specialization includes 'Corporate Law'. Could you update the query?"}, {"role": "assistant", "content": "SELECT l.lawyer_id,\n       CONCAT(l.first_name, ' ', l.last_name) AS lawyer_name,\n       CONCAT(p.first_name, ' ', p.last_name) AS partner_name\nFROM legal_services.lawyers l\nJOIN legal_services.lawyers p\n  ON l.firm_id = p.firm_id\n AND p.is_partner = true\nWHERE l.specialization ILIKE '%Corporate Law%';"}, {"role": "user", "content": "Also only show those who were hired after 2020-01-01."}, {"role": "assistant", "content": "SELECT l.lawyer_id,\n       CONCAT(l.first_name, ' ', l.last_name) AS lawyer_name,\n       CONCAT(p.first_name, ' ', p.last_name) AS partner_name\nFROM legal_services.lawyers l\nJOIN legal_services.lawyers p\n  ON l.firm_id = p.firm_id\n AND p.is_partner = true\nWHERE l.specialization ILIKE '%Corporate Law%'\n  AND l.hire_date > '2020-01-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.lawyers (\n    lawyer_id character varying(64) NOT NULL,  -- unique identifier for the lawyer\n    first_name character varying(100) NOT NULL, -- lawyer's first name\n    last_name character varying(100) NOT NULL, -- lawyer's last name\n    bar_number character varying(64) UNIQUE NOT NULL, -- lawyer's bar association number\n    firm_id character varying(64), -- FK to law_firms table\n    email character varying(128) UNIQUE NOT NULL, -- lawyer's professional email\n    phone character varying(32), -- lawyer's contact phone number\n    specialization text, -- areas of legal expertise\n    hire_date timestamp NOT NULL, -- date the lawyer was hired or joined\n    is_partner boolean DEFAULT false, -- flag indicating if the lawyer is a partner\n    PRIMARY KEY (lawyer_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Count the number of law firms founded in each decade. Show the decade (e.g., 1990s, 2000s) and the count."}, {"role": "assistant", "content": "SELECT CONCAT(FLOOR(EXTRACT(YEAR FROM founded_date) / 10) * 10, 's') AS decade, COUNT(*) AS firm_count FROM law_firms WHERE founded_date IS NOT NULL GROUP BY decade ORDER BY decade;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.clients ( client_id text PRIMARY KEY, first_name text, last_name text, company_name text, email text UNIQUE, phone text, address text, date_registered timestamp, status text )\nCREATE TABLE legal_services.law_firms ( firm_id text PRIMARY KEY, firm_name text, address text, phone text, website text, founded_date date, managing_partner_id text )\nCREATE TABLE legal_services.documents ( document_id text PRIMARY KEY, case_id text, document_name text, document_type text, storage_path text, uploaded_by_lawyer_id text, upload_timestamp timestamp, version int, description text )\n"}
{"conversations": [{"role": "user", "content": "Get all active SUI coins with their owner and balance."}, {"role": "assistant", "content": "SELECT coin_type, owner, balance\nFROM sui_coins\nWHERE status = 'active';"}, {"role": "user", "content": "Join metadata to include the coin symbol and decimals."}, {"role": "assistant", "content": "SELECT c.coin_type,\n       m.symbol,\n       m.decimals,\n       c.owner,\n       c.balance\nFROM sui_coins c\nJOIN sui_coins_metadata m\n  ON c.coin_type = m.coin_type\nWHERE c.status = 'active';"}, {"role": "user", "content": "Only include coins where balance is greater than 500 and add the description."}, {"role": "assistant", "content": "SELECT c.coin_type,\n       m.symbol,\n       m.decimals,\n       m.description,\n       c.owner,\n       c.balance\nFROM sui_coins c\nJOIN sui_coins_metadata m\n  ON c.coin_type = m.coin_type\nWHERE c.status = 'active'\n  AND CAST(c.balance AS numeric) > 500;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE erc1155_approval_for_all ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash text, log_index integer, contract_address text )\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address text, wallet_address text, amount text, pk integer )\nCREATE TABLE nft_holders ( block_number bigint, contract_address text, wallet_address text, token_id text, contract_type text, amount text, pk text )\nCREATE TABLE nft_holder_historical ( block_number bigint, contract_address text, wallet_address text, token_id text, contract_type text, amount text, pk integer )\nCREATE TABLE sui_coins ( object_id text, status text, coin_type text, balance text, owner text )\nCREATE TABLE sui_coins_metadata ( object_id text, coin_type text, status text, decimals bigint, description text, icon_url text, symbol text, name text )\nCREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE token_prices_latest ( blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash text, log_index integer, contract_address text, pk integer )\nCREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\nCREATE TABLE token_info ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, tick text, max_supply decimal, lim decimal, wlim decimal, dec integer, creator text )\nCREATE 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 )\nCREATE TABLE mud_holesky_redstone ( address text, table_id text, key_bytes text, key0 text, key1 text, static_data text, encoded_lengths text, dynamic_data text, is_deleted boolean, block_number bigint, log_index bigint )\nCREATE TABLE token_balances_bitcoin ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply text, amount text )\nCREATE 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 )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, log_index integer, type text, tick text, id text, amt decimal, from_address text, to_address text )\nCREATE 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 )\nCREATE TABLE token_balances_avalanche ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all tokens with a price below $1 and a 24-hour trading volume over $5 million."}, {"role": "assistant", "content": "SELECT token_name, token_symbol, price, total_volume FROM token_basic_info WHERE price < 1 AND total_volume::numeric > 5000000;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE token_basic_info ( coin_id character varying(100) NOT NULL, token_name character varying(100) NOT NULL, token_symbol character varying(100) NOT NULL, token_address character varying(100) NOT NULL, chain text, price double precision, price_change_percentage_1h double precision, price_change_percentage_24h double precision, price_change_percentage_7d double precision, highest_price_24h double precision, lowest_price_24h double precision, market_cap double precision, market_cap_rank bigint, market_cap_change_percentage_24h text, total_volume text, narrative text, trend_rank bigint )\n"}
{"conversations": [{"role": "user", "content": "List all appointments scheduled in the next 30 days with appointment_id, client_id, case_id, and any invoice_id linked to that case."}, {"role": "assistant", "content": "SELECT\n  a.appointment_id,\n  a.client_id,\n  a.case_id,\n  i.invoice_id\nFROM legal_services.appointments AS a\nLEFT JOIN legal_services.invoices AS i\n  ON a.case_id = i.case_id\nWHERE a.start_time BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '30 days';"}, {"role": "user", "content": "Change to include only appointments with status 'Scheduled' and invoices that are not fully paid."}, {"role": "assistant", "content": "SELECT\n  a.appointment_id,\n  a.client_id,\n  a.case_id,\n  i.invoice_id\nFROM legal_services.appointments AS a\nLEFT JOIN legal_services.invoices AS i\n  ON a.case_id = i.case_id\nWHERE a.start_time BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '30 days'\n  AND a.status = 'Scheduled'\n  AND (i.status IS NULL OR i.status <> 'Paid');"}, {"role": "user", "content": "Also include only those where the case_type is 'Corporate'."}, {"role": "assistant", "content": "SELECT\n  a.appointment_id,\n  a.client_id,\n  a.case_id,\n  i.invoice_id\nFROM legal_services.appointments AS a\nJOIN legal_services.cases AS c\n  ON a.case_id = c.case_id\nLEFT JOIN legal_services.invoices AS i\n  ON a.case_id = i.case_id\nWHERE a.start_time BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '30 days'\n  AND a.status = 'Scheduled'\n  AND (i.status IS NULL OR i.status <> 'Paid')\n  AND c.case_type = 'Corporate';"}, {"role": "user", "content": "Finally, order by start_time ascending and return only the first 10 rows."}, {"role": "assistant", "content": "SELECT\n  a.appointment_id,\n  a.client_id,\n  a.case_id,\n  i.invoice_id\nFROM legal_services.appointments AS a\nJOIN legal_services.cases AS c\n  ON a.case_id = c.case_id\nLEFT JOIN legal_services.invoices AS i\n  ON a.case_id = i.case_id\nWHERE a.start_time BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '30 days'\n  AND a.status = 'Scheduled'\n  AND (i.status IS NULL OR i.status <> 'Paid')\n  AND c.case_type = 'Corporate'\nORDER BY a.start_time ASC\nLIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.law_firms (\n    firm_id character varying(64) NOT NULL,  -- unique identifier for the law firm\n    firm_name character varying(200) NOT NULL, -- official name of the law firm\n    address text NOT NULL, -- primary address of the firm\n    phone character varying(32), -- firm's main phone number\n    website character varying(255), -- firm's website URL\n    founded_date date, -- date the firm was established\n    managing_partner_id character varying(64), -- FK to lawyers table (optional)\n    PRIMARY KEY (firm_id)\n)\nCREATE TABLE legal_services.cases (\n    case_id character varying(64) NOT NULL,  -- unique identifier for the case/matter\n    case_number character varying(100) UNIQUE, -- official case number (court or internal)\n    case_name text NOT NULL, -- descriptive name or title for the case\n    client_id character varying(64) NOT NULL, -- FK to clients table\n    lead_lawyer_id character varying(64) NOT NULL, -- FK to lawyers table (primary lawyer responsible)\n    case_type character varying(100) NOT NULL, -- e.g., Litigation, Corporate, Family Law, IP\n    status character varying(50) NOT NULL, -- e.g., Open, Closed, Pending, On Hold, Appealed\n    date_opened timestamp NOT NULL, -- date the case was formally opened\n    date_closed timestamp, -- date the case was closed (nullable)\n    description text, -- detailed description of the case\n    court_jurisdiction character varying(128), -- court or jurisdiction if applicable\n    PRIMARY KEY (case_id)\n)\nCREATE TABLE legal_services.time_entries (\n    entry_id character varying(64) NOT NULL,  -- unique identifier for the time entry\n    case_id character varying(64) NOT NULL, -- FK to cases table\n    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table (who performed the work)\n    date_worked date NOT NULL, -- date the work was performed\n    hours_spent numeric(5, 2) NOT NULL CHECK (hours_spent > 0), -- duration of work in hours (e.g., 1.5 for 1h 30m)\n    billing_rate numeric(10, 2) NOT NULL, -- hourly rate applied for this entry\n    description text NOT NULL, -- detailed description of the work performed\n    is_billable boolean DEFAULT true, -- whether this time entry is billable to the client\n    is_billed boolean DEFAULT false, -- whether this entry has been included in an invoice\n    invoice_id character varying(64), -- FK to invoices table (once billed)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the entry was recorded\n    PRIMARY KEY (entry_id)\n)\nCREATE TABLE legal_services.invoices (\n    invoice_id character varying(64) NOT NULL,  -- unique identifier for the invoice\n    invoice_number character varying(100) UNIQUE NOT NULL, -- user-facing invoice number\n    client_id character varying(64) NOT NULL, -- FK to clients table\n    case_id character varying(64), -- FK to cases table (optional, could be general retainer)\n    issue_date date NOT NULL, -- date the invoice was generated\n    due_date date NOT NULL, -- date the payment is due\n    total_amount numeric(12, 2) NOT NULL, -- total amount due on the invoice\n    amount_paid numeric(12, 2) DEFAULT 0.00, -- amount already paid\n    status character varying(50) NOT NULL, -- e.g., Draft, Sent, Paid, Partially Paid, Overdue, Void\n    payment_date timestamp, -- date the invoice was fully paid (nullable)\n    notes text, -- additional notes or terms on the invoice\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,\n    PRIMARY KEY (invoice_id)\n)\nCREATE TABLE legal_services.appointments (\n    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment\n    client_id character varying(64) NOT NULL, -- FK to clients table\n    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table\n    case_id character varying(64), -- FK to cases table (optional, if related to a specific case)\n    start_time timestamp NOT NULL, -- scheduled start date and time\n    end_time timestamp NOT NULL, -- scheduled end date and time\n    location text, -- location of the meeting (address or virtual link)\n    subject character varying(255), -- subject or purpose of the appointment\n    notes text, -- additional notes for the appointment\n    status character varying(50) NOT NULL, -- e.g., Scheduled, Completed, Canceled, Rescheduled\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,\n    PRIMARY KEY (appointment_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me all maintenance logs for 'Oil Change' services performed in the last 3 months, including the vehicle ID, service date, and cost."}, {"role": "assistant", "content": "SELECT vehicle_id, service_date, cost FROM transportation.maintenance_logs WHERE service_type = 'Oil Change' AND service_date >= CURRENT_DATE - INTERVAL '3 months';"}, {"role": "user", "content": "Can you also include the mechanic name and filter to only show services that cost more than $100?"}, {"role": "assistant", "content": "SELECT vehicle_id, service_date, cost, mechanic_name FROM transportation.maintenance_logs WHERE service_type = 'Oil Change' AND service_date >= CURRENT_DATE - INTERVAL '3 months' AND cost > 100;"}, {"role": "user", "content": "Now order these results by service date with the most recent first and limit to 10 records."}, {"role": "assistant", "content": "SELECT vehicle_id, service_date, cost, mechanic_name FROM transportation.maintenance_logs WHERE service_type = 'Oil Change' AND service_date >= CURRENT_DATE - INTERVAL '3 months' AND cost > 100 ORDER BY service_date DESC LIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.maintenance_logs (\n    log_id character varying(64) NOT NULL,  -- unique identifier for the maintenance record\n    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle serviced\n    service_date date NOT NULL, -- date the service was performed\n    odometer_reading integer, -- vehicle mileage at time of service\n    service_type character varying(128) NOT NULL, -- type of service (e.g., Oil Change, Tire Rotation, Engine Repair)\n    description text NOT NULL, -- detailed description of work done\n    cost numeric(10, 2), -- cost of the service\n    mechanic_name character varying(128), -- name or ID of the mechanic/shop\n    next_service_due_date date, -- recommended date for next service\n    PRIMARY KEY (log_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all ERC20 tokens with their names and symbols where the price is greater than $100, sorted by price in descending order."}, {"role": "assistant", "content": "SELECT scm.name, scm.symbol, tpl.price FROM sui_coins_metadata scm JOIN token_prices_latest tpl ON scm.coin_type = tpl.address WHERE tpl.price > 100 ORDER BY tpl.price DESC;"}, {"role": "user", "content": "I think there's an error in your query - it should be joining on address not coin_type. Also, can you add the decimals to the results?"}, {"role": "assistant", "content": "SELECT scm.name, scm.symbol, scm.decimals, tpl.price FROM sui_coins_metadata scm JOIN token_prices_latest tpl ON scm.object_id = tpl.address WHERE tpl.price > 100 ORDER BY tpl.price DESC;"}, {"role": "user", "content": "Now filter these results to only show tokens with decimals equal to 18 and limit to the top 10."}, {"role": "assistant", "content": "SELECT scm.name, scm.symbol, scm.decimals, tpl.price FROM sui_coins_metadata scm JOIN token_prices_latest tpl ON scm.object_id = tpl.address WHERE tpl.price > 100 AND scm.decimals = 18 ORDER BY tpl.price DESC LIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE nft_holder_historical ( block_number.bigint, contract_address.text, wallet_address.text, token_id.text, contract_type.text, amount.text, pk.integer )\nCREATE TABLE sui_coins_metadata ( object_id.text, coin_type.text, status.text, decimals.bigint, description.text, icon_url.text, symbol.text, name.text )\nCREATE TABLE sui_nfts ( object_id.text, status.text, collection_type.text, package_id.text, previous_transaction.text, display.text, owner.text, name.text )\nCREATE 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 )\nCREATE TABLE token_prices_latest ( blockchain.text, address.text, decimals.bigint, symbol.text, price.real, timestamp.timestamp )\nCREATE TABLE erc20_approval ( block_number.bigint, block_timestamp.timestamp, transaction_index.integer, transaction_hash.text, log_index.integer, contract_address.text, pk.integer )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE token_balances_avalanche ( block_number.bigint, block_timestamp.timestamp, tick.text, wallet_address.text, total_supply.decimal, amount.decimal )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all pairs of diagnoses that belong to the same medical record. Show record_id, diagnosis_id from the first entry as diag1_id, and diagnosis_id from the second entry as diag2_id."}, {"role": "assistant", "content": "SELECT d1.record_id,\n       d1.diagnosis_id AS diag1_id,\n       d2.diagnosis_id AS diag2_id\nFROM healthcare.diagnoses d1\nJOIN healthcare.diagnoses d2\n  ON d1.record_id = d2.record_id\n AND d1.diagnosis_id < d2.diagnosis_id;"}, {"role": "user", "content": "Only include pairs where both diagnoses are chronic."}, {"role": "assistant", "content": "SELECT d1.record_id,\n       d1.diagnosis_id AS diag1_id,\n       d2.diagnosis_id AS diag2_id\nFROM healthcare.diagnoses d1\nJOIN healthcare.diagnoses d2\n  ON d1.record_id = d2.record_id\n AND d1.diagnosis_id < d2.diagnosis_id\nWHERE d1.is_chronic = TRUE\n  AND d2.is_chronic = TRUE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.diagnoses (\n    diagnosis_id character varying(64) NOT NULL, -- unique identifier for the diagnosis entry\n    record_id character varying(64) NOT NULL, -- FK linking to the specific medical record entry\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    doctor_id character varying(64) NOT NULL, -- FK to doctors table (diagnosing doctor)\n    diagnosis_code character varying(20) NOT NULL, -- standard code (e.g., ICD-10)\n    code_type character varying(10) NOT NULL DEFAULT 'ICD-10', -- type of code used\n    description text, -- textual description of the diagnosis\n    diagnosis_date date NOT NULL, -- date the diagnosis was made\n    status character varying(32) NOT NULL, -- e.g., Active, Resolved, Ruled Out\n    is_chronic boolean DEFAULT false, -- flag for chronic conditions\n    PRIMARY KEY (diagnosis_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me all claims filed in the last 6 months with their associated policy details and customer information."}, {"role": "assistant", "content": "SELECT cl.claim_id, cl.incident_date, cl.status, cl.settlement_amount, p.policy_number, p.product_id, p.coverage_limit, c.first_name, c.last_name, c.phone_number FROM insurance.claims cl JOIN insurance.policies p ON cl.policy_id = p.policy_id JOIN insurance.customers c ON cl.customer_id = c.customer_id WHERE cl.reported_date >= CURRENT_DATE - INTERVAL '6 months';"}, {"role": "user", "content": "I also want to see how many documents were submitted for each claim."}, {"role": "assistant", "content": "SELECT cl.claim_id, cl.incident_date, cl.status, cl.settlement_amount, p.policy_number, p.product_id, p.coverage_limit, c.first_name, c.last_name, c.phone_number, COUNT(cd.document_id) AS document_count FROM insurance.claims cl JOIN insurance.policies p ON cl.policy_id = p.policy_id JOIN insurance.customers c ON cl.customer_id = c.customer_id LEFT JOIN insurance.claim_documents cd ON cl.claim_id = cd.claim_id WHERE cl.reported_date >= CURRENT_DATE - INTERVAL '6 months' GROUP BY cl.claim_id, cl.incident_date, cl.status, cl.settlement_amount, p.policy_number, p.product_id, p.coverage_limit, c.first_name, c.last_name, c.phone_number;"}, {"role": "user", "content": "Now filter to only show claims that have police reports."}, {"role": "assistant", "content": "SELECT cl.claim_id, cl.incident_date, cl.status, cl.settlement_amount, p.policy_number, p.product_id, p.coverage_limit, c.first_name, c.last_name, c.phone_number, COUNT(cd.document_id) AS document_count FROM insurance.claims cl JOIN insurance.policies p ON cl.policy_id = p.policy_id JOIN insurance.customers c ON cl.customer_id = c.customer_id JOIN insurance.claim_documents cd ON cl.claim_id = cd.claim_id WHERE cl.reported_date >= CURRENT_DATE - INTERVAL '6 months' AND cd.document_type = 'Police Report' GROUP BY cl.claim_id, cl.incident_date, cl.status, cl.settlement_amount, p.policy_number, p.product_id, p.coverage_limit, c.first_name, c.last_name, c.phone_number;"}, {"role": "user", "content": "Finally, show me the average time between incident date and reported date for these claims with police reports."}, {"role": "assistant", "content": "SELECT AVG(EXTRACT(EPOCH FROM (cl.reported_date - cl.incident_date))/3600) AS avg_hours_to_report FROM insurance.claims cl JOIN insurance.claim_documents cd ON cl.claim_id = cd.claim_id WHERE cl.reported_date >= CURRENT_DATE - INTERVAL '6 months' AND cd.document_type = 'Police Report';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.customers (\n    customer_id character varying(64) NOT NULL,  -- unique identifier for the customer\n    first_name character varying(100) NOT NULL, -- customer's first name\n    last_name character varying(100) NOT NULL, -- customer's last name\n    date_of_birth date NOT NULL, -- customer's date of birth\n    ssn_hash character varying(128), -- Hashed social security number (or national ID)\n    address_line1 character varying(255) NOT NULL,\n    address_line2 character varying(255),\n    city character varying(100) NOT NULL,\n    state character varying(50) NOT NULL,\n    zip_code character varying(20) NOT NULL,\n    country character varying(50) NOT NULL DEFAULT 'USA',\n    phone_number character varying(30),\n    email character varying(128) UNIQUE, -- unique email address\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the customer record was created\n    updated_at timestamp, -- when the customer record was last updated\n    status character varying(20) NOT NULL DEFAULT 'Active', -- e.g., Active, Inactive, Prospect\n    PRIMARY KEY (customer_id)\n)\nCREATE TABLE insurance.policies (\n    policy_id character varying(64) NOT NULL, -- unique identifier for the policy\n    customer_id character varying(64) NOT NULL, -- identifier for the policyholder (FK to customers)\n    product_id character varying(64) NOT NULL, -- identifier for the insurance product (FK to insurance_products)\n    agent_id character varying(64), -- identifier for the agent who sold the policy (FK to agents)\n    policy_number character varying(100) NOT NULL UNIQUE, -- customer-facing policy number\n    start_date date NOT NULL, -- date the policy coverage begins\n    end_date date NOT NULL, -- date the policy coverage ends\n    premium_amount numeric(12, 2) NOT NULL, -- total premium for the policy term\n    coverage_limit numeric(15, 2) NOT NULL, -- maximum amount covered\n    deductible numeric(10, 2) NOT NULL, -- amount customer pays before coverage kicks in\n    status character varying(30) NOT NULL, -- e.g., Active, Expired, Cancelled, Pending\n    issued_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the policy was issued\n    cancellation_date date,\n    cancellation_reason text,\n    PRIMARY KEY (policy_id)\n)\nCREATE TABLE insurance.claims (\n    claim_id character varying(64) NOT NULL, -- unique identifier for the claim\n    policy_id character varying(64) NOT NULL, -- identifier of the policy under which the claim is made (FK to policies)\n    customer_id character varying(64) NOT NULL, -- identifier of the customer making the claim (FK to customers)\n    incident_date timestamp NOT NULL, -- date and time of the incident leading to the claim\n    reported_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the claim was reported\n    description text NOT NULL, -- detailed description of the incident and claim\n    estimated_loss numeric(15, 2), -- initial estimated cost of the loss\n    status character varying(30) NOT NULL, -- e.g., Filed, Processing, Under Review, Approved, Denied, Settled\n    settlement_amount numeric(15, 2), -- final amount paid out\n    settlement_date date,\n    claim_handler_id character varying(64), -- identifier for the employee handling the claim (FK to employees/adjusters)\n    police_report_number character varying(100),\n    PRIMARY KEY (claim_id)\n)\nCREATE TABLE insurance.premium_payments (\n    payment_id character varying(64) NOT NULL, -- unique identifier for the payment\n    policy_id character varying(64) NOT NULL, -- identifier of the policy the payment is for (FK to policies)\n    customer_id character varying(64) NOT NULL, -- identifier of the customer making the payment (FK to customers)\n    payment_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the payment was received\n    amount_paid numeric(12, 2) NOT NULL, -- amount of the payment\n    payment_method character varying(50), -- e.g., Credit Card, Bank Transfer, Check\n    transaction_reference character varying(128) UNIQUE, -- reference from payment processor\n    due_date date, -- due date for this payment installment\n    payment_period_start date, -- start date of the period this payment covers\n    payment_period_end date, -- end date of the period this payment covers\n    status character varying(30) NOT NULL DEFAULT 'Completed', -- e.g., Completed, Pending, Failed, Refunded\n    PRIMARY KEY (payment_id)\n)\nCREATE TABLE insurance.claim_documents (\n    document_id character varying(64) NOT NULL, -- unique identifier for the document\n    claim_id character varying(64) NOT NULL, -- identifier of the claim this document relates to (FK to claims)\n    document_type character varying(50) NOT NULL, -- e.g., Police Report, Photo, Invoice, Medical Bill\n    file_name character varying(255) NOT NULL, -- original name of the uploaded file\n    file_path character varying(512) NOT NULL, -- storage path (e.g., S3 URL, network path)\n    file_size_bytes integer, -- size of the file in bytes\n    mime_type character varying(100), -- MIME type of the file (e.g., 'image/jpeg', 'application/pdf')\n    uploaded_by character varying(64), -- identifier of the user/system who uploaded (FK to users/customers)\n    uploaded_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- time of upload\n    description text, -- optional description of the document\n    PRIMARY KEY (document_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me the top 5 tokens by market cap on the Ethereum chain, along with their 24-hour trading volume and price from the token_basic_info table."}, {"role": "assistant", "content": "SELECT token_name, token_symbol, market_cap, total_volume, price FROM token_basic_info WHERE chain = 'Ethereum' ORDER BY market_cap DESC LIMIT 5;"}, {"role": "user", "content": "Can you also include their 7-day price change percentage and filter for tokens with a positive 24-hour price change?"}, {"role": "assistant", "content": "SELECT token_name, token_symbol, market_cap, total_volume, price, price_change_percentage_7d FROM token_basic_info WHERE chain = 'Ethereum' AND price_change_percentage_24h > 0 ORDER BY market_cap DESC LIMIT 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE token_basic_info ( coin_id character varying(100) NOT NULL, token_name character varying(100) NOT NULL, token_symbol character varying(100) NOT NULL, token_address character varying(100) NOT NULL, chain text, price double precision, price_change_percentage_1h double precision, price_change_percentage_24h double precision, price_change_percentage_7d double precision, highest_price_24h double precision, lowest_price_24h double precision, market_cap double precision, market_cap_rank bigint, market_cap_change_percentage_24h text, total_volume text, narrative text, trend_rank bigint )\nCREATE TABLE narrative_info ( narrative character varying(512) NOT NULL, top_3_coins text, price_change_percentage_1h double precision, price_change_percentage_24h double precision, price_change_percentage_7d double precision, market_cap double precision, volume_24h double precision, trend_rank bigint, token_num bigint )\nCREATE TABLE cex_token_balance ( snapshot_time character varying(32) NOT NULL, chain character varying(128) NOT NULL, address character varying(128) NOT NULL, exchange character varying(512) NOT NULL, token_address character varying(128) NOT NULL, token_symbol character varying(512), balance numeric(38,10), usd_value numeric(38,14), price double precision )\nCREATE TABLE smart_money_token_performance ( token_address character varying(100) NOT NULL, token_symbol character varying(100), pnl numeric(38,2), net_flow numeric(38,2), avg_cost numeric(38,16), price double precision, realized_ratio numeric(10,2), roi numeric(10,2), chain character varying(100) )\nCREATE TABLE smart_money_token_inflow ( token_address character varying(100) NOT NULL, token_symbol character varying(100), token_amount numeric(38,2), usd_value numeric(38,2), avg_price numeric(38,6), type int, address_amount integer, narrative character varying(100), chain character varying(100) )\n"}
{"conversations": [{"role": "user", "content": "List the name and symbol for all assets that do not have a corresponding entry with the key 'website' in the metadata table."}, {"role": "assistant", "content": "SELECT T1.name , T1.symbol FROM trading_platform.assets AS T1 LEFT JOIN trading_platform.metadata AS T2 ON T1.asset_id  =  T2.asset_id AND T2.key  =  'website' WHERE T2.metadata_id IS NULL"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.users ( user_id character varying(64) NOT NULL, username character varying(128) NOT NULL, email character varying(128) NOT NULL, password_hash text NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (user_id) )\nCREATE TABLE trading_platform.wallets ( wallet_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, address character varying(128) NOT NULL, private_key text NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (wallet_id) )\nCREATE 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 )\nCREATE TABLE trading_platform.trades (\n    trade_id character varying(64) NOT NULL,  -- unique identifier for the trade\n    order_id character varying(64) NOT NULL, -- identifier of the order that led to the trade\n    buyer_id character varying(64) NOT NULL, -- identifier of the buyer\n    seller_id character varying(64) NOT NULL, -- identifier of the seller\n    asset_id character varying(64) NOT NULL, -- identifier of the asset being traded\n    quantity numeric(38,14) NOT NULL, -- quantity of the asset in the trade\n    price numeric(38,14) NOT NULL, -- price per unit of the asset\n    traded_at timestamp NOT NULL, -- time when the trade was executed\n    PRIMARY KEY (trade_id)\n)\nCREATE TABLE trading_platform.assets ( asset_id text PRIMARY KEY, name text, symbol text, type text )\nCREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )\nCREATE TABLE trading_platform.dapps ( dapp_id.text, name.text, description.text, url.text )\nCREATE TABLE trading_platform.metadata (\n    metadata_id character varying(64) NOT NULL,  -- unique identifier for the metadata\n    asset_id character varying(64) NOT NULL, -- identifier of the asset the metadata is associated with\n    key character varying(128) NOT NULL, -- key of the metadata\n    value text NOT NULL, -- value of the metadata\n    PRIMARY KEY (metadata_id)\n)\nCREATE TABLE trading_platform.kyc_audit (\n    kyc_audit_id character varying(64) NOT NULL,  -- unique identifier for the KYC audit\n    user_id character varying(64) NOT NULL, -- identifier of the user being audited\n    status character varying(32) NOT NULL, -- status of the KYC audit (e.g., pending, approved, rejected)\n    reviewed_at timestamp NOT NULL, -- time when the KYC audit was reviewed\n    PRIMARY KEY (kyc_audit_id)\n)\n"}
{"conversations": [{"role": "user", "content": "What is the average speed of train number T9876 during its last journey?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information on the average speed of train number T9876 during its last journey. The data in the trains table does not include details about travel speed or journey-specific performance metrics."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.trains ( train_id.text, train_number.text, model.text, manufacturer.text, year_manufactured.integer, capacity.integer, status.text, last_maintenance_date.date, next_maintenance_date.date )\n"}
{"conversations": [{"role": "user", "content": "Show all likes made by user 'U555' on comments, including the comment_id and like creation time."}, {"role": "assistant", "content": "SELECT like_id, comment_id, created_at\nFROM social_media.likes\nWHERE user_id = 'U555' AND comment_id IS NOT NULL;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE social_media.posts ( post_id.text, 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 )\nCREATE TABLE social_media.likes ( like_id.text, user_id.text, post_id.text, comment_id.text, created_at.timestamp )\nCREATE TABLE social_media.hashtags ( hashtag_id text, tag_name text, created_at timestamp )\nCREATE TABLE social_media.post_hashtags ( post_hashtag_id text, post_id text, hashtag_id text )\nCREATE TABLE social_media.conversation_participants ( participant_id character varying(64) NOT NULL, conversation_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, joined_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, last_read_at timestamp, PRIMARY KEY (participant_id), CONSTRAINT unique_user_conversation UNIQUE (conversation_id, user_id) )\nCREATE TABLE social_media.notifications (\n    notification_id character varying(64) NOT NULL, -- unique identifier for the notification\n    recipient_user_id character varying(64) NOT NULL, -- user receiving the notification (FK to users.user_id)\n    sender_user_id character varying(64), -- user triggering the notification (FK to users.user_id, can be null for system notifications)\n    notification_type character varying(30) NOT NULL, -- type of notification ('like', 'comment', 'follow', 'mention', 'message')\n    target_entity_id character varying(64), -- ID of the related entity (post_id, comment_id, user_id, conversation_id)\n    target_entity_type character varying(20), -- type of the related entity ('post', 'comment', 'user', 'conversation')\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp notification was created\n    read_at timestamp, -- timestamp notification was marked as read\n    PRIMARY KEY (notification_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show the total trade amount for each account. Include the account_id and account_number."}, {"role": "assistant", "content": "SELECT\n  T1.account_id,\n  T1.account_number,\n  SUM(T2.total_amount) AS total_traded_amount\nFROM financial_services.accounts AS T1\nINNER JOIN financial_services.trades AS T2\n  ON T1.account_id = T2.account_id\nGROUP BY\n  T1.account_id,\n  T1.account_number;"}, {"role": "user", "content": "Only include trades with a status of 'SETTLED'."}, {"role": "assistant", "content": "SELECT\n  T1.account_id,\n  T1.account_number,\n  SUM(T2.total_amount) AS total_traded_amount\nFROM financial_services.accounts AS T1\nINNER JOIN financial_services.trades AS T2\n  ON T1.account_id = T2.account_id\nWHERE\n  T2.status = 'SETTLED'\nGROUP BY\n  T1.account_id,\n  T1.account_number;"}, {"role": "user", "content": "Filter out accounts where the total traded amount for settled trades is less than 5000."}, {"role": "assistant", "content": "SELECT\n  T1.account_id,\n  T1.account_number,\n  SUM(T2.total_amount) AS total_traded_amount\nFROM financial_services.accounts AS T1\nINNER JOIN financial_services.trades AS T2\n  ON T1.account_id = T2.account_id\nWHERE\n  T2.status = 'SETTLED'\nGROUP BY\n  T1.account_id,\n  T1.account_number\nHAVING\n  SUM(T2.total_amount) >= 5000;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE financial_services.customers ( customer_id text, first_name text, last_name text, date_of_birth date, ssn_hash text, address text, city text, state text, zip_code text, country text, email text, phone_number text, created_at timestamp, status text, risk_profile text )\nCREATE 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 )\nCREATE TABLE financial_services.transactions (\n    transaction_id character varying(64) NOT NULL, -- unique identifier for the transaction\n    account_id character varying(64) NOT NULL, -- account involved in the transaction\n    related_account_id character varying(64), -- counterpart account for transfers\n    transaction_type character varying(50) NOT NULL, -- e.g., Deposit, Withdrawal, Transfer, Payment, Fee, Interest\n    amount numeric(19, 4) NOT NULL, -- transaction amount\n    currency character varying(3) NOT NULL, -- transaction currency\n    transaction_date timestamp NOT NULL, -- exact time of the transaction\n    effective_date date NOT NULL, -- date the transaction affects the balance\n    description text, -- description or memo of the transaction\n    status character varying(32) NOT NULL, -- e.g., Pending, Completed, Failed, Reversed\n    reference_number character varying(128), -- external reference if applicable (e.g., check number)\n    PRIMARY KEY (transaction_id),\n    FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id),\n    FOREIGN KEY (related_account_id) REFERENCES financial_services.accounts(account_id)\n)\nCREATE TABLE financial_services.securities ( security_id.text, ticker_symbol.text, isin_code.text, cusip_code.text, security_name.text, security_type.text, exchange.text, currency.text, issuer_name.text, sector.text, last_updated.timestamp )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE financial_services.employees (\n    employee_id character varying(64) NOT NULL,  -- unique identifier for the employee\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    job_title character varying(100) NOT NULL, -- e.g., Teller, Branch Manager, Financial Advisor, Analyst\n    department character varying(100), -- e.g., Retail Banking, Wealth Management, IT\n    branch_id character varying(64), -- Identifier for the branch they work at (if applicable)\n    email character varying(128) NOT NULL UNIQUE,\n    phone_extension character varying(20),\n    hire_date date NOT NULL,\n    termination_date date, -- Date of termination, null if currently employed\n    manager_id character varying(64), -- Self-referencing key for manager relationship\n    status character varying(32) NOT NULL, -- e.g., Active, Terminated, On Leave\n    PRIMARY KEY (employee_id),\n    FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), -- Assuming a branches table exists\n    FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me all chronic diagnoses along with their descriptions and the patient IDs, sorted by diagnosis date in descending order."}, {"role": "assistant", "content": "SELECT patient_id, description, diagnosis_date FROM healthcare.diagnoses WHERE is_chronic = true ORDER BY diagnosis_date DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List the service_id, service_name, and agency_id for all active services that have an online application URL provided."}, {"role": "assistant", "content": "SELECT service_id,\n       service_name,\n       agency_id\nFROM government_services.services\nWHERE is_active = TRUE\n  AND online_application_url IS NOT NULL;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id text PRIMARY KEY, 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 )\nCREATE TABLE government_services.services ( service_id text, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days integer, is_active boolean, online_application_url text )\nCREATE TABLE government_services.documents (\n    document_id character varying(64) NOT NULL, -- unique identifier for the document instance\n    application_id character varying(64), -- FK to applications table (optional, could be linked to citizen directly)\n    citizen_id character varying(64) NOT NULL, -- FK to citizens table\n    document_type character varying(100) NOT NULL, -- e.g., Passport Scan, Proof of Address, Birth Certificate\n    file_reference text NOT NULL, -- reference to the stored file (e.g., S3 URL, internal path)\n    upload_timestamp timestamp NOT NULL,\n    expiry_date date,\n    verification_status character varying(30) DEFAULT 'Pending', -- e.g., Pending, Verified, Rejected\n    verified_by_employee_id character varying(64), -- FK to employees table\n    verification_timestamp timestamp,\n    PRIMARY KEY (document_id)\n)\nCREATE 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) )\nCREATE TABLE government_services.appointments (\n    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment\n    citizen_id character varying(64) NOT NULL, -- FK to citizens table\n    employee_id character varying(64), -- FK to employees table (optional, if assigned)\n    location_id character varying(64), -- FK to service_locations table (if physical)\n    service_id character varying(64), -- FK to services table (optional, if related to specific service)\n    scheduled_start_time timestamp NOT NULL,\n    scheduled_end_time timestamp,\n    purpose text NOT NULL, -- reason for the appointment\n    status character varying(30) NOT NULL, -- e.g., Scheduled, Completed, Cancelled, No-Show\n    booking_method character varying(50), -- e.g., Online, Phone, In-Person\n    created_at timestamp NOT NULL, -- when the appointment was booked\n    notes text,\n    PRIMARY KEY (appointment_id)\n)\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Show the full names and contact emails of all citizens who have made a payment for an application that is currently in 'Pending' status."}, {"role": "assistant", "content": "SELECT DISTINCT c.first_name || ' ' || c.last_name AS full_name, c.contact_email\nFROM government_services.citizens c\nJOIN government_services.payments p ON c.citizen_id = p.citizen_id\nJOIN government_services.applications a ON p.application_id = a.application_id\nWHERE a.status = 'Pending';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id text PRIMARY KEY, 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me the total fare collected from all completed bookings (status = 'completed') grouped by passenger_id."}, {"role": "assistant", "content": "SELECT passenger_id, SUM(fare) AS total_fare FROM transportation.bookings WHERE status = 'completed' GROUP BY passenger_id;"}, {"role": "user", "content": "Now include only passengers who have spent more than $200 in total and order by total_fare in descending order."}, {"role": "assistant", "content": "SELECT passenger_id, SUM(fare) AS total_fare FROM transportation.bookings WHERE status = 'completed' GROUP BY passenger_id HAVING SUM(fare) > 200 ORDER BY total_fare DESC;"}, {"role": "user", "content": "Can you also include the count of bookings for each passenger in the results?"}, {"role": "assistant", "content": "SELECT passenger_id, SUM(fare) AS total_fare, COUNT(*) AS booking_count FROM transportation.bookings WHERE status = 'completed' GROUP BY passenger_id HAVING SUM(fare) > 200 ORDER BY total_fare DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Which exchanges hold the highest total USD value of tokens on the Ethereum chain, and what are their top 3 tokens by USD value?"}, {"role": "assistant", "content": "SELECT exchange, token_symbol, usd_value FROM (SELECT exchange, token_symbol, usd_value, ROW_NUMBER() OVER (PARTITION BY exchange ORDER BY usd_value DESC) as rank FROM cex_token_balance WHERE chain = 'Ethereum') WHERE rank <= 3 ORDER BY exchange, usd_value DESC;"}, {"role": "user", "content": "Can you modify this to show the top 5 exchanges by total USD value instead, and include their total balance across all tokens?"}, {"role": "assistant", "content": "SELECT exchange, SUM(usd_value) as total_usd_value, SUM(balance) as total_balance FROM cex_token_balance WHERE chain = 'Ethereum' GROUP BY exchange ORDER BY total_usd_value DESC LIMIT 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Find currently employed employees whose direct manager has been terminated. Display the employee's full name, hire date, manager's full name, and manager's termination date."}, {"role": "assistant", "content": "SELECT e.employee_id,\n       CONCAT(e.first_name, ' ', e.last_name) AS employee_full_name,\n       e.hire_date,\n       CONCAT(m.first_name, ' ', m.last_name) AS manager_full_name,\n       m.termination_date\nFROM government_services.employees e\nJOIN government_services.employees m ON e.manager_employee_id = m.employee_id\nWHERE e.termination_date IS NULL\n  AND m.termination_date IS NOT NULL;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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) )\nCREATE 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 )\nCREATE TABLE government_services.employees (\n    employee_id character varying(64) NOT NULL, -- unique identifier for the government employee\n    agency_id character varying(64) NOT NULL, -- FK to agencies table\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    job_title character varying(150) NOT NULL,\n    department character varying(100),\n    work_email character varying(128) NOT NULL UNIQUE,\n    work_phone character varying(32),\n    hire_date date NOT NULL,\n    termination_date date, -- null if currently employed\n    access_level character varying(50), -- Role or permission level\n    manager_employee_id character varying(64), -- FK to self for reporting structure\n    PRIMARY KEY (employee_id)\n)\nCREATE 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 )\nCREATE 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) )\nCREATE TABLE government_services.notifications ( notification_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, application_id character varying(64), message_subject character varying(255), message_body text NOT NULL, channel character varying(30) NOT NULL, sent_at timestamp NOT NULL, status character varying(30) NOT NULL, related_entity_type character varying(50), related_entity_id character varying(64), PRIMARY KEY (notification_id) )\n"}
{"conversations": [{"role": "user", "content": "List the citizen IDs for individuals who have both uploaded documents and made payments."}, {"role": "assistant", "content": "SELECT DISTINCT T1.citizen_id FROM documents AS T1 JOIN payments AS T2 ON T1.citizen_id = T2.citizen_id"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.documents ( document_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, document_type character varying(100) NOT NULL, file_reference text NOT NULL, upload_timestamp timestamp NOT NULL, expiry_date date, verification_status character varying(30) DEFAULT 'Pending', verified_by_employee_id character varying(64), verification_timestamp timestamp, PRIMARY KEY (document_id) )\nCREATE TABLE government_services.payments ( payment_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, service_id character varying(64), amount numeric(12, 2) NOT NULL, currency character varying(3) NOT NULL DEFAULT 'USD', payment_method character varying(50), payment_provider_reference character varying(128), payment_timestamp timestamp NOT NULL, status character varying(30) NOT NULL, notes text, PRIMARY KEY (payment_id) )\n"}
{"conversations": [{"role": "user", "content": "Show me assets along with their associated 'symbol' metadata value. Assume an assets table with asset_id exists."}, {"role": "assistant", "content": "SELECT a.asset_id, m.value FROM assets a JOIN metadata m ON a.asset_id = m.asset_id WHERE m.key = 'symbol'"}, {"role": "user", "content": "Now, also include the 'name' metadata value for these assets in the same result."}, {"role": "assistant", "content": "SELECT a.asset_id, m_symbol.value AS symbol, m_name.value AS name FROM assets a LEFT JOIN metadata m_symbol ON a.asset_id = m_symbol.asset_id AND m_symbol.key = 'symbol' LEFT JOIN metadata m_name ON a.asset_id = m_name.asset_id AND m_name.key = 'name'"}, {"role": "user", "content": "For assets that have both 'symbol' and 'name' metadata, list the asset ID and the count of *all* metadata entries they have."}, {"role": "assistant", "content": "SELECT a.asset_id, COUNT(m_all.metadata_id) FROM assets a JOIN metadata m_symbol ON a.asset_id = m_symbol.asset_id AND m_symbol.key = 'symbol' JOIN metadata m_name ON a.asset_id = m_name.asset_id AND m_name.key = 'name' JOIN metadata m_all ON a.asset_id = m_all.asset_id GROUP BY a.asset_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. \n##Table Structure\nCREATE TABLE trading_platform.utxos ( utxo_id text PRIMARY KEY, transaction_id text, output_index int, address text, amount numeric, spent boolean )\nCREATE TABLE trading_platform.dapps ( dapp_id text PRIMARY KEY, name text, description text, url text )\nCREATE TABLE trading_platform.peers ( peer_id text PRIMARY KEY, ip_address text, port int, last_seen timestamp )\nCREATE TABLE trading_platform.metadata ( metadata_id text PRIMARY KEY, asset_id text, key text, value text )\nCREATE TABLE trading_platform.notifications ( notification_id text PRIMARY KEY, user_id text, message text, sent_at timestamp, read_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "For each service location, find its nearest accessible location by geographic distance."}, {"role": "assistant", "content": "SELECT sl.location_id,\n       sl.location_name,\n       nearest.location_id   AS nearest_location_id,\n       nearest.location_name AS nearest_location_name\nFROM government_services.service_locations sl\nJOIN LATERAL (\n  SELECT sl2.location_id,\n         sl2.location_name\n  FROM government_services.service_locations sl2\n  WHERE sl2.is_accessible = TRUE\n    AND sl2.location_id <> sl.location_id\n  ORDER BY ((sl.latitude - sl2.latitude)^2 + (sl.longitude - sl2.longitude)^2) ASC\n  LIMIT 1\n) AS nearest ON TRUE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.service_locations ( location_id.text, agency_id.text, location_name.text, address.text, city.text, state.text, postal_code.text, latitude.numeric, longitude.numeric, operating_hours.text, contact_phone.text, is_accessible.boolean )\n"}
{"conversations": [{"role": "user", "content": "List usernames and the length of their 'bio' field for users whose 'is_verified' status is true."}, {"role": "assistant", "content": "SELECT username, LENGTH(bio) AS bio_length FROM social_media.users WHERE is_verified IS TRUE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List each patient's active insurance policy and the number of prescriptions they have during that policy. Show patient_id, plan_id, policy_number, and prescription_count."}, {"role": "assistant", "content": "SELECT pi.patient_id, pi.plan_id, pi.policy_number, COUNT(p.prescription_id) AS prescription_count\nFROM healthcare.patient_insurance pi\nLEFT JOIN healthcare.prescriptions p\n  ON pi.patient_id = p.patient_id\n  AND DATE(p.prescription_date) BETWEEN pi.effective_date AND COALESCE(pi.expiration_date, CURRENT_DATE)\nGROUP BY pi.patient_id, pi.plan_id, pi.policy_number;"}, {"role": "user", "content": "Only include patients with more than 5 prescriptions."}, {"role": "assistant", "content": "SELECT pi.patient_id, pi.plan_id, pi.policy_number, COUNT(p.prescription_id) AS prescription_count\nFROM healthcare.patient_insurance pi\nLEFT JOIN healthcare.prescriptions p\n  ON pi.patient_id = p.patient_id\n  AND DATE(p.prescription_date) BETWEEN pi.effective_date AND COALESCE(pi.expiration_date, CURRENT_DATE)\nGROUP BY pi.patient_id, pi.plan_id, pi.policy_number\nHAVING COUNT(p.prescription_id) > 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.appointments ( appointment_id text, patient_id text, doctor_id text, appointment_time timestamp, duration_minutes integer, reason text, status text, location_id text, notes text, created_at timestamp )\nCREATE TABLE healthcare.medications ( medication_id text, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )\nCREATE TABLE healthcare.prescriptions ( prescription_id.text, record_id.text, patient_id.text, doctor_id.text, medication_id.text, dosage.text, frequency.text, route.text, start_date.date, end_date.date, quantity_dispensed.numeric, refills_allowed.integer, prescription_date.timestamp )\nCREATE TABLE healthcare.patient_insurance ( patient_insurance_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, plan_id character varying(64) NOT NULL, policy_number character varying(100) NOT NULL, group_number character varying(100), subscriber_name character varying(200), effective_date date NOT NULL, expiration_date date, is_primary boolean NOT NULL DEFAULT true, PRIMARY KEY (patient_insurance_id), UNIQUE (patient_id, plan_id, policy_number) )\n"}
{"conversations": [{"role": "user", "content": "List each employee's first and last name along with the count of active services offered by their agency."}, {"role": "assistant", "content": "SELECT e.first_name, e.last_name, COUNT(s.service_id) AS active_service_count\nFROM government_services.employees e\nJOIN government_services.services s ON e.agency_id = s.agency_id AND s.is_active = TRUE\nGROUP BY e.employee_id, e.first_name, e.last_name;"}, {"role": "user", "content": "Actually, only include employees whose service count is greater than 5."}, {"role": "assistant", "content": "SELECT e.first_name, e.last_name, COUNT(s.service_id) AS active_service_count\nFROM government_services.employees e\nJOIN government_services.services s ON e.agency_id = s.agency_id AND s.is_active = TRUE\nGROUP BY e.employee_id, e.first_name, e.last_name\nHAVING COUNT(s.service_id) > 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id character varying(64) NOT NULL, national_id_number character varying(128) NOT NULL UNIQUE, 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, contact_email character varying(128) UNIQUE, contact_phone character varying(32), registration_date timestamp NOT NULL, is_verified boolean DEFAULT false, PRIMARY KEY (citizen_id) )\nCREATE 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) )\nCREATE TABLE government_services.services ( service_id character varying(64) NOT NULL, agency_id character varying(64) NOT NULL, service_name character varying(255) NOT NULL, description text, category character varying(100), eligibility_criteria text, standard_fee numeric(10, 2) DEFAULT 0.00, average_processing_time_days integer, is_active boolean DEFAULT true, online_application_url character varying(255), PRIMARY KEY (service_id) )\nCREATE TABLE government_services.applications ( application_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, service_id character varying(64) NOT NULL, submitted_at timestamp NOT NULL, status character varying(50) NOT NULL, last_updated_at timestamp NOT NULL, assigned_employee_id character varying(64), decision_date date, notes text, reference_number character varying(100) UNIQUE, PRIMARY KEY (application_id) )\nCREATE TABLE government_services.payments ( payment_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, service_id character varying(64), amount numeric(12, 2) NOT NULL, currency character varying(3) NOT NULL DEFAULT 'USD', payment_method character varying(50), payment_provider_reference character varying(128), payment_timestamp timestamp NOT NULL, status character varying(30) NOT NULL, notes text, PRIMARY KEY (payment_id) )\nCREATE TABLE government_services.employees ( employee_id character varying(64) NOT NULL, agency_id character varying(64) NOT NULL, 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, access_level character varying(50), manager_employee_id character varying(64), PRIMARY KEY (employee_id) )\nCREATE 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) )\nCREATE 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) )\nCREATE TABLE government_services.notifications ( notification_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, application_id character varying(64), message_subject character varying(255), message_body text NOT NULL, channel character varying(30) NOT NULL, sent_at timestamp NOT NULL, status character varying(30) NOT NULL, related_entity_type character varying(50), related_entity_id character varying(64), PRIMARY KEY (notification_id) )\n"}
{"conversations": [{"role": "user", "content": "Can you help me get the total number of operational platforms across all stations?"}, {"role": "assistant", "content": "db.platforms.countDocuments({ status: 'Operational' });"}], "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. \n##Table Structure\n// db.createCollection('platforms')\n// Optional: db.platforms.createIndex({ platform_id: 1 }, { unique: true })\n// Optional: db.platforms.createIndex({ station_id: 1 })\n{\n  _id: ObjectId(),\n  platform_id: \"plat_123\", // String (unique)\n  station_id: \"station_xyz\", // String (references stations.station_id)\n  platform_number: \"1A\", // String\n  track_number: \"T1\", // String\n  status: \"Operational\", // String ('Operational', 'Maintenance', 'Closed')\n  length_meters: 250.50, // Decimal128 or Double\n  accessible: true // Boolean\n}\n// db.createCollection('routes')\n// Optional: db.routes.createIndex({ route_id: 1 }, { unique: true })\n{\n  _id: ObjectId(),\n  route_id: \"route_ne_corr\", // String (unique)\n  route_name: \"Northeast Corridor\", // String\n  description: \"High-speed rail linking Boston and Washington D.C.\", // String\n  origin_station_id: \"station_bos\", // String (references stations.station_id)\n  destination_station_id: \"station_was\", // String (references stations.station_id)\n  is_active: true // Boolean\n}\n// db.createCollection('route_stations')\n// Optional: db.route_stations.createIndex({ route_station_id: 1 }, { unique: true })\n// Optional: db.route_stations.createIndex({ route_id: 1, sequence_order: 1 }, { unique: true })\n{\n  _id: ObjectId(),\n  route_station_id: \"rs_ne_1\", // String (unique)\n  route_id: \"route_ne_corr\", // String (references routes.route_id)\n  station_id: \"station_bos\", // String (references stations.station_id)\n  sequence_order: 1, // Int32\n  distance_from_previous_km: null, // Decimal128 or Double (null for first stop)\n  typical_stop_duration_minutes: null // Int32 (null for origin/destination or if no stop)\n}\n// --- OR --- Embed within the Route document:\n// {\n//   _id: ObjectId(), route_id: \"route_ne_corr\", ...,\n//   stations: [\n//     { station_id: \"station_bos\", sequence_order: 1, distance_from_previous_km: null, typical_stop_duration_minutes: null },\n//     { station_id: \"station_pvd\", sequence_order: 2, distance_from_previous_km: 70.5, typical_stop_duration_minutes: 5 },\n//     ...\n//   ]\n// }\n// db.createCollection('schedules')\n// Optional: db.schedules.createIndex({ schedule_id: 1 }, { unique: true })\n// Optional: db.schedules.createIndex({ route_id: 1, departure_datetime: 1 })\n{\n  _id: ObjectId(),\n  schedule_id: \"sched_1122\", // String (unique)\n  train_id: \"train_789\", // String (references trains.train_id)\n  route_id: \"route_ne_corr\", // String (references routes.route_id)\n  departure_datetime: ISODate(\"2024-05-10T08:00:00-04:00\"), // Date (with timezone)\n  arrival_datetime: ISODate(\"2024-05-10T15:30:00-04:00\"), // Date (with timezone)\n  status: \"Scheduled\", // String ('Scheduled', 'On Time', 'Delayed', 'Cancelled', 'Arrived')\n  notes: \"Track work expected near Philadelphia\" // String\n}\n// db.createCollection('schedule_stops')\n// Optional: db.schedule_stops.createIndex({ stop_id: 1 }, { unique: true })\n// Optional: db.schedule_stops.createIndex({ schedule_id: 1, sequence_order: 1 }, { unique: true })\n{\n  _id: ObjectId(),\n  stop_id: \"stop_sched1122_1\", // String (unique)\n  schedule_id: \"sched_1122\", // String (references schedules.schedule_id)\n  station_id: \"station_bos\", // String (references stations.station_id)\n  platform_id: \"plat_bos_3\", // String (references platforms.platform_id, nullable)\n  sequence_order: 1, // Int32\n  scheduled_arrival_time: null, // Date\n  scheduled_departure_time: ISODate(\"2024-05-10T08:00:00-04:00\"), // Date\n  actual_arrival_time: null, // Date\n  actual_departure_time: ISODate(\"2024-05-10T08:01:00-04:00\"), // Date\n  status: \"On Time\" // String\n}\n// --- OR --- Embed within the Schedule document using an array 'stops'\n// db.createCollection('passengers')\n// Optional: db.passengers.createIndex({ passenger_id: 1 }, { unique: true })\n// Optional: db.passengers.createIndex({ email: 1 }, { unique: true, sparse: true })\n// Optional: db.passengers.createIndex({ phone_number: 1 }, { unique: true, sparse: true })\n{\n  _id: ObjectId(),\n  passenger_id: \"pass_pqr\", // String (unique)\n  first_name: \"Alice\", // String\n  last_name: \"Smith\", // String\n  email: \"alice.smith@example.com\", // String (unique, sparse)\n  phone_number: \"+15551234567\", // String (unique, sparse)\n  date_of_birth: ISODate(\"1990-03-20\"), // Date\n  loyalty_program_id: \"LOYALTY123\", // String\n  created_at: ISODate(\"2023-02-01T11:00:00Z\") // Date\n}\n// db.createCollection('staff')\n// Optional: db.staff.createIndex({ staff_id: 1 }, { unique: true })\n// Optional: db.staff.createIndex({ employee_number: 1 }, { unique: true })\n// Optional: db.staff.createIndex({ contact_email: 1 }, { unique: true, sparse: true })\n{\n  _id: ObjectId(),\n  staff_id: \"staff_mno\", // String (unique)\n  first_name: \"Bob\", // String\n  last_name: \"Jones\", // String\n  role: \"Conductor\", // String\n  primary_station_id: null, // String (references stations.station_id, nullable)\n  employee_number: \"E12345\", // String (unique)\n  hire_date: ISODate(\"2018-06-01\"), // Date\n  contact_email: \"bob.jones@example-rail.com\", // String (unique, sparse)\n  contact_phone: \"+15559876543\", // String\n  is_active: true // Boolean\n}\n"}
{"conversations": [{"role": "user", "content": "Show me the username and email of all users who own at least one wallet."}, {"role": "assistant", "content": "SELECT DISTINCT T1.username, T1.email FROM blockchain.users AS T1 JOIN blockchain.wallets AS T2 ON T1.user_id = T2.user_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE blockchain.wallets ( wallet_id.text, user_id.text, address_id.text, private_key.text )\nCREATE TABLE blockchain.users ( user_id.text, username.text, email.text, password_hash.text )\n"}
{"conversations": [{"role": "user", "content": "Find all pairs of distinct appointments for the same case that overlap in time. Show both appointment IDs, the case_id, and the start_time and end_time of each appointment."}, {"role": "assistant", "content": "SELECT a1.appointment_id AS appointment_id_1,\n       a2.appointment_id AS appointment_id_2,\n       a1.case_id,\n       a1.start_time AS start_time_1,\n       a1.end_time   AS end_time_1,\n       a2.start_time AS start_time_2,\n       a2.end_time   AS end_time_2\nFROM legal_services.appointments a1\nJOIN legal_services.appointments a2\n  ON a1.case_id = a2.case_id\n AND a1.appointment_id < a2.appointment_id\n AND a1.start_time < a2.end_time\n AND a2.start_time < a1.end_time;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.appointments ( appointment_id.text, client_id.text, lawyer_id.text, case_id.text, start_time.timestamp, end_time.timestamp, location.text, subject.text, notes.text, status.text, created_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "What are the training programs or certifications completed by a staff member with the role of Platform Supervisor?"}, {"role": "assistant", "content": "I'm sorry, but I don't have access to information about the training programs or certifications completed by staff members. The data available to me only includes basic staff details such as name, role, and contact information. For details on training or certifications, please refer to the HR department or relevant training records."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.staff ( staff_id text PRIMARY KEY, first_name text, last_name text, role text, primary_station_id text, employee_number text UNIQUE, hire_date date, contact_email text UNIQUE, contact_phone text, is_active boolean )\n"}
{"conversations": [{"role": "user", "content": "Show each contract's address along with the total number of events it has emitted and the total number of transactions sent to it."}, {"role": "assistant", "content": "SELECT\n  c.address,\n  COUNT(e.event_id) AS event_count,\n  COUNT(t.transaction_id) AS tx_count\nFROM web3.contracts c\nLEFT JOIN web3.events e\n  ON c.contract_id = e.contract_id\nLEFT JOIN web3.transactions t\n  ON c.address = t.to_address\nGROUP BY c.address;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.contracts (\n    contract_id character varying(64) NOT NULL,  -- unique identifier for the contract\n    address character varying(128) NOT NULL, -- address of the deployed contract\n    abi text NOT NULL, -- application binary interface of the contract\n    bytecode text NOT NULL, -- bytecode of the contract\n    deployer_address character varying(128) NOT NULL, -- address of the deployer\n    deployed_at timestamp NOT NULL, -- time when the contract was deployed\n    network_id character varying(64) NOT NULL, -- identifier of the network where the contract is deployed\n    status character varying(32) NOT NULL, -- status of the contract (e.g., active, deprecated)\n    PRIMARY KEY (contract_id)\n)\nCREATE TABLE web3.events (\n    event_id character varying(64) NOT NULL,  -- unique identifier for the event\n    contract_id character varying(64) NOT NULL, -- identifier of the contract emitting the event\n    event_name character varying(128) NOT NULL, -- name of the event\n    data text NOT NULL, -- data payload of the event\n    emitted_at timestamp NOT NULL, -- time when the event was emitted\n    transaction_id character varying(64) NOT NULL, -- identifier of the transaction that triggered the event\n    log_index integer NOT NULL, -- index of the event log in the transaction\n    PRIMARY KEY (event_id)\n)\nCREATE TABLE web3.transactions (\n    transaction_id character varying(64) NOT NULL,  -- unique identifier for the transaction\n    from_address character varying(128) NOT NULL, -- address of the sender\n    to_address character varying(128), -- address of the receiver (can be null for contract deployment)\n    value numeric(38,14) NOT NULL, -- value transferred\n    gas_used integer NOT NULL, -- amount of gas used by the transaction\n    gas_price numeric(38,14) NOT NULL, -- price of gas at the time of the transaction\n    block_number integer NOT NULL, -- block number containing the transaction\n    timestamp timestamp NOT NULL, -- time when the transaction was mined\n    input_data text, -- input data of the transaction (can be null)\n    status character varying(32) NOT NULL, -- status of the transaction (e.g., success, failed)\n    nonce integer NOT NULL, -- nonce of the sender at the time of the transaction\n    PRIMARY KEY (transaction_id)\n)\nCREATE TABLE web3.tokens (\n    token_id character varying(64) NOT NULL,  -- unique identifier for the token\n    contract_address character varying(128) NOT NULL, -- address of the token contract\n    token_name character varying(128) NOT NULL, -- name of the token\n    token_symbol character varying(32) NOT NULL, -- symbol of the token\n    decimals integer NOT NULL, -- number of decimals for the token\n    total_supply numeric(38,14) NOT NULL, -- total supply of the token\n    PRIMARY KEY (token_id)\n)\nCREATE TABLE web3.token_transfers (\n    transfer_id character varying(64) NOT NULL,  -- unique identifier for the transfer\n    token_id character varying(64) NOT NULL, -- identifier of the token being transferred\n    from_address character varying(128) NOT NULL, -- address of the sender\n    to_address character varying(128) NOT NULL, -- address of the receiver\n    value numeric(38,14) NOT NULL, -- amount of tokens transferred\n    transaction_id character varying(64) NOT NULL, -- identifier of the transaction containing the transfer\n    log_index integer NOT NULL, -- index of the transfer log in the transaction\n    PRIMARY KEY (transfer_id)\n)\nCREATE TABLE web3.users (\n    user_id character varying(64) NOT NULL,  -- unique identifier for the user\n    username character varying(128) NOT NULL, -- username of the user\n    email character varying(128) NOT NULL, -- email address of the user\n    password_hash text NOT NULL, -- hashed password of the user\n    created_at timestamp NOT NULL, -- time when the user account was created\n    PRIMARY KEY (user_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show each policy number and the total amount paid for it across all premium payments received so far."}, {"role": "assistant", "content": "SELECT T1.policy_number, SUM(T2.amount_paid) FROM insurance.policies AS T1 JOIN insurance.premium_payments AS T2 ON T1.policy_id = T2.policy_id GROUP BY T1.policy_number;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.customers ( customer_id text PRIMARY KEY, first_name text, last_name text, date_of_birth date, ssn_hash text, address_line1 text, address_line2 text, city text, state text, zip_code text, country text, phone_number text, email text, created_at timestamp, updated_at timestamp, status text )\nCREATE 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 )\nCREATE TABLE insurance.claims (\n    claim_id character varying(64) NOT NULL, -- unique identifier for the claim\n    policy_id character varying(64) NOT NULL, -- identifier of the policy under which the claim is made (FK to policies)\n    customer_id character varying(64) NOT NULL, -- identifier of the customer making the claim (FK to customers)\n    incident_date timestamp NOT NULL, -- date and time of the incident leading to the claim\n    reported_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the claim was reported\n    description text NOT NULL, -- detailed description of the incident and claim\n    estimated_loss numeric(15, 2), -- initial estimated cost of the loss\n    status character varying(30) NOT NULL, -- e.g., Filed, Processing, Under Review, Approved, Denied, Settled\n    settlement_amount numeric(15, 2), -- final amount paid out\n    settlement_date date,\n    claim_handler_id character varying(64), -- identifier for the employee handling the claim (FK to employees/adjusters)\n    police_report_number character varying(100),\n    PRIMARY KEY (claim_id)\n)\nCREATE 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 )\nCREATE TABLE insurance.agents ( agent_id text, 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 )\nCREATE TABLE insurance.premium_payments (\n    payment_id character varying(64) NOT NULL, -- unique identifier for the payment\n    policy_id character varying(64) NOT NULL, -- identifier of the policy the payment is for (FK to policies)\n    customer_id character varying(64) NOT NULL, -- identifier of the customer making the payment (FK to customers)\n    payment_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the payment was received\n    amount_paid numeric(12, 2) NOT NULL, -- amount of the payment\n    payment_method character varying(50), -- e.g., Credit Card, Bank Transfer, Check\n    transaction_reference character varying(128) UNIQUE, -- reference from payment processor\n    due_date date, -- due date for this payment installment\n    payment_period_start date, -- start date of the period this payment covers\n    payment_period_end date, -- end date of the period this payment covers\n    status character varying(30) NOT NULL DEFAULT 'Completed', -- e.g., Completed, Pending, Failed, Refunded\n    PRIMARY KEY (payment_id)\n)\nCREATE TABLE insurance.claim_documents ( document_id character varying(64) NOT NULL, claim_id character varying(64) NOT NULL, document_type character varying(50) NOT NULL, file_name character varying(255) NOT NULL, file_path character varying(512) NOT NULL, file_size_bytes integer, mime_type character varying(100), uploaded_by character varying(64), uploaded_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, description text, PRIMARY KEY (document_id) )\n"}
{"conversations": [{"role": "user", "content": "Show me the document name and the date worked for time entries logged by the same lawyer."}, {"role": "assistant", "content": "SELECT T1.document_name ,  T2.date_worked FROM documents AS T1 JOIN time_entries AS T2 ON T1.uploaded_by_lawyer_id  =  T2.lawyer_id"}, {"role": "user", "content": "Only show pairs where the time entry is billable."}, {"role": "assistant", "content": "SELECT T1.document_name ,  T2.date_worked FROM documents AS T1 JOIN time_entries AS T2 ON T1.uploaded_by_lawyer_id  =  T2.lawyer_id WHERE T2.is_billable  =  true"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.documents ( document_id text, case_id text, document_name text, document_type text, storage_path text, uploaded_by_lawyer_id text, upload_timestamp timestamp, version integer, description text )\nCREATE TABLE legal_services.time_entries (\n    entry_id character varying(64) NOT NULL,  -- unique identifier for the time entry\n    case_id character varying(64) NOT NULL, -- FK to cases table\n    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table (who performed the work)\n    date_worked date NOT NULL, -- date the work was performed\n    hours_spent numeric(5, 2) NOT NULL CHECK (hours_spent > 0), -- duration of work in hours (e.g., 1.5 for 1h 30m)\n    billing_rate numeric(10, 2) NOT NULL, -- hourly rate applied for this entry\n    description text NOT NULL, -- detailed description of the work performed\n    is_billable boolean DEFAULT true, -- whether this time entry is billable to the client\n    is_billed boolean DEFAULT false, -- whether this entry has been included in an invoice\n    invoice_id character varying(64), -- FK to invoices table (once billed)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the entry was recorded\n    PRIMARY KEY (entry_id)\n)\n"}
{"conversations": [{"role": "user", "content": "What is the history of incidents or accidents that occurred on platform 5 at station GHI?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information about the history of incidents or accidents on platform 5 at station GHI. My data is limited to the structural and operational details of the platforms, such as platform ID, station ID, and status. For incident history, you may need to consult a different database or contact the relevant authorities."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.platforms ( platform_id.text, station_id.text, platform_number.text, track_number.text, status.text, length_meters.numeric, accessible.boolean )\n"}
{"conversations": [{"role": "user", "content": "For each player, list the total number of 'Legendary' rarity items they have in their inventory, along with the titles of the respective games those items belong to."}, {"role": "assistant", "content": "SELECT pi.player_id, g.game_id, g.title, COUNT(*) AS legendary_item_count\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.in_game_items i ON pi.item_id = i.item_id\nJOIN gaming_technology.games g ON i.game_id = g.game_id\nWHERE i.rarity = 'Legendary'\nGROUP BY pi.player_id, g.game_id, g.title;"}, {"role": "user", "content": "Please modify the query to only include players who have more than 2 'Legendary' items per game."}, {"role": "assistant", "content": "SELECT pi.player_id, g.game_id, g.title, COUNT(*) AS legendary_item_count\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.in_game_items i ON pi.item_id = i.item_id\nJOIN gaming_technology.games g ON i.game_id = g.game_id\nWHERE i.rarity = 'Legendary'\nGROUP BY pi.player_id, g.game_id, g.title\nHAVING COUNT(*) > 2;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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 )\nCREATE 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) )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Count the number of staff members for each position."}, {"role": "assistant", "content": "SELECT\n  position,\n  COUNT(staff_id) AS staff_count\nFROM hospitality_technology.staff\nGROUP BY\n  position;"}, {"role": "user", "content": "Only show positions that have more than 10 staff members and order the results by the count descending."}, {"role": "assistant", "content": "SELECT\n  position,\n  COUNT(staff_id) AS staff_count\nFROM hospitality_technology.staff\nGROUP BY\n  position\nHAVING\n  COUNT(staff_id) > 10\nORDER BY\n  staff_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties (\n    property_id character varying(64) NOT NULL,  -- unique identifier for the property (hotel, resort, etc.)\n    property_name character varying(255) NOT NULL, -- name of the property\n    address_line1 character varying(255) NOT NULL, -- primary address line\n    address_line2 character varying(255), -- secondary address line\n    city character varying(100) NOT NULL, -- city\n    state_province character varying(100), -- state or province\n    postal_code character varying(20) NOT NULL, -- zip or postal code\n    country_code character varying(3) NOT NULL, -- ISO country code (e.g., USA, CAN)\n    phone_number character varying(30), -- main contact phone\n    email_address character varying(255), -- main contact email\n    property_type character varying(50) NOT NULL, -- e.g., Hotel, Resort, B&B, Motel\n    star_rating numeric(2,1), -- star rating (e.g., 4.5)\n    timezone character varying(64) NOT NULL, -- IANA timezone ID (e.g., America/New_York)\n    manager_staff_id character varying(64), -- FK to staff table for the general manager\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record creation time\n    updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record last update time\n    PRIMARY KEY (property_id)\n)\nCREATE TABLE hospitality_technology.reservations ( reservation_id text, property_id text, guest_id text, room_id text, room_type_id text, check_in_date date, check_out_date date, actual_check_in_ts timestamp, actual_check_out_ts timestamp, num_adults integer, num_children integer, status text, booking_source text, rate_plan_id text, total_amount numeric, amount_paid numeric, special_requests text, created_at timestamp, updated_at timestamp )\nCREATE 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 )\nCREATE TABLE hospitality_technology.payments ( payment_id text, reservation_id text, guest_id text, bill_id text, amount numeric, currency_code text, payment_method text, card_type text, card_last_four text, transaction_ref text, payment_timestamp timestamp, status text, staff_id_processed text, notes text )\n"}
{"conversations": [{"role": "user", "content": "List all pairs of contracts that were deployed on the same calendar day but on different network IDs. Show the deployment date, the contract addresses, and the network IDs for both contracts in each pair."}, {"role": "assistant", "content": "SELECT DATE(c1.deployed_at) AS deployment_date, c1.address AS contract1_address, c2.address AS contract2_address, c1.network_id AS contract1_network, c2.network_id AS contract2_network FROM web3.contracts c1 JOIN web3.contracts c2 ON DATE(c1.deployed_at) = DATE(c2.deployed_at) AND c1.network_id != c2.network_id WHERE c1.contract_id < c2.contract_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.contracts ( contract_id character varying(64) NOT NULL, address character varying(128) NOT NULL, abi text NOT NULL, bytecode text NOT NULL, deployer_address character varying(128) NOT NULL, deployed_at timestamp NOT NULL, network_id character varying(64) NOT NULL, status character varying(32) NOT NULL, PRIMARY KEY (contract_id) )\n"}
{"conversations": [{"role": "user", "content": "How many documents were uploaded in the year 2023?"}, {"role": "assistant", "content": "SELECT count(*) FROM government_services.documents WHERE date_part('year', upload_timestamp) = 2023;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.documents ( document_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, document_type character varying(100) NOT NULL, file_reference text NOT NULL, upload_timestamp timestamp NOT NULL, expiry_date date, verification_status character varying(30) DEFAULT 'Pending', verified_by_employee_id character varying(64), verification_timestamp timestamp, PRIMARY KEY (document_id) )\n"}
{"conversations": [{"role": "user", "content": "Count the number of users for each location where the location is not empty."}, {"role": "assistant", "content": "SELECT location, COUNT(user_id) FROM social_media.users WHERE location IS NOT NULL AND location != '' GROUP BY location;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "For each citizen who has made at least one payment, show the citizen's full name, number of payments, and total amount paid, grouped by currency."}, {"role": "assistant", "content": "SELECT\n  c.first_name || ' ' || c.last_name AS full_name,\n  p.currency,\n  COUNT(*) AS payment_count,\n  SUM(p.amount) AS total_amount\nFROM government_services.citizens c\nJOIN government_services.payments p ON c.citizen_id = p.citizen_id\nGROUP BY full_name, p.currency;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id character varying(64) NOT NULL, national_id_number character varying(128) NOT NULL UNIQUE, 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, contact_email character varying(128) UNIQUE, contact_phone character varying(32), registration_date timestamp NOT NULL, is_verified boolean DEFAULT false, PRIMARY KEY (citizen_id) )\nCREATE TABLE government_services.payments ( payment_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, service_id character varying(64), amount numeric(12, 2) NOT NULL, currency character varying(3) NOT NULL DEFAULT 'USD', payment_method character varying(50), payment_provider_reference character varying(128), payment_timestamp timestamp NOT NULL, status character varying(30) NOT NULL, notes text, PRIMARY KEY (payment_id) )\nCREATE TABLE government_services.employees ( employee_id character varying(64) NOT NULL, agency_id character varying(64) NOT NULL, 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, access_level character varying(50), manager_employee_id character varying(64), PRIMARY KEY (employee_id) )\nCREATE 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) )\nCREATE 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) )\nCREATE TABLE government_services.notifications ( notification_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, application_id character varying(64), message_subject character varying(255), message_body text NOT NULL, channel character varying(30) NOT NULL, sent_at timestamp NOT NULL, status character varying(30) NOT NULL, related_entity_type character varying(50), related_entity_id character varying(64), PRIMARY KEY (notification_id) )\n"}
{"conversations": [{"role": "user", "content": "For each item, can you show the total quantity held by all players and the most recent acquisition date for that item?"}, {"role": "assistant", "content": "SELECT item_id, SUM(quantity) AS total_quantity, MAX(acquired_at) AS last_acquired_at\nFROM gaming_technology.player_inventory\nGROUP BY item_id;"}, {"role": "user", "content": "Please only show items where total_quantity is at least 50."}, {"role": "assistant", "content": "SELECT item_id, SUM(quantity) AS total_quantity, MAX(acquired_at) AS last_acquired_at\nFROM gaming_technology.player_inventory\nGROUP BY item_id\nHAVING SUM(quantity) >= 50;"}, {"role": "user", "content": "Can you also sort the result by total_quantity in descending order?"}, {"role": "assistant", "content": "SELECT item_id, SUM(quantity) AS total_quantity, MAX(acquired_at) AS last_acquired_at\nFROM gaming_technology.player_inventory\nGROUP BY item_id\nHAVING SUM(quantity) >= 50\nORDER BY total_quantity DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.player_inventory (\n    inventory_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an inventory entry\n    player_id uuid NOT NULL, -- FK linking to the player owning the item\n    item_id uuid NOT NULL, -- FK linking to the item definition\n    quantity integer NOT NULL DEFAULT 1, -- number of items held (for stackable items)\n    acquired_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the item was acquired\n    instance_data jsonb, -- data specific to this instance (e.g., weapon mods, durability)\n    PRIMARY KEY (inventory_id),\n    -- Optional unique constraint if items are non-stackable or unique instances\n    -- UNIQUE (player_id, item_id) -- Use if quantity is always 1\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (item_id) REFERENCES gaming_technology.in_game_items(item_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me the total number of items acquired per player for each item type, along with the player's username."}, {"role": "assistant", "content": "SELECT p.player_id, p.username, igi.item_type, SUM(pi.quantity) AS total_acquired\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.players p ON pi.player_id = p.player_id\nJOIN gaming_technology.in_game_items igi ON pi.item_id = igi.item_id\nGROUP BY p.player_id, p.username, igi.item_type;"}, {"role": "user", "content": "Can you filter this to only include item types 'Weapon' and 'Armor'?"}, {"role": "assistant", "content": "SELECT p.player_id, p.username, igi.item_type, SUM(pi.quantity) AS total_acquired\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.players p ON pi.player_id = p.player_id\nJOIN gaming_technology.in_game_items igi ON pi.item_id = igi.item_id\nWHERE igi.item_type IN ('Weapon', 'Armor')\nGROUP BY p.player_id, p.username, igi.item_type;"}, {"role": "user", "content": "Actually, I want to see only those players who have acquired more than 5 of either item type."}, {"role": "assistant", "content": "SELECT p.player_id, p.username, igi.item_type, SUM(pi.quantity) AS total_acquired\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.players p ON pi.player_id = p.player_id\nJOIN gaming_technology.in_game_items igi ON pi.item_id = igi.item_id\nWHERE igi.item_type IN ('Weapon', 'Armor')\nGROUP BY p.player_id, p.username, igi.item_type\nHAVING SUM(pi.quantity) > 5;"}, {"role": "user", "content": "Please also include the player's registration_date in the result."}, {"role": "assistant", "content": "SELECT p.player_id, p.username, p.registration_date, igi.item_type, SUM(pi.quantity) AS total_acquired\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.players p ON pi.player_id = p.player_id\nJOIN gaming_technology.in_game_items igi ON pi.item_id = igi.item_id\nWHERE igi.item_type IN ('Weapon', 'Armor')\nGROUP BY p.player_id, p.username, p.registration_date, igi.item_type\nHAVING SUM(pi.quantity) > 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.players ( player_id uuid NOT NULL DEFAULT gen_random_uuid(), username character varying(100) NOT NULL UNIQUE, email character varying(255) NOT NULL UNIQUE, password_hash text NOT NULL, registration_date timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, last_login timestamp with time zone, country_code character(2), status character varying(20) NOT NULL DEFAULT 'active', profile_data jsonb, PRIMARY KEY (player_id) )\nCREATE TABLE gaming_technology.developers ( developer_id.uuid, name.text, country.text, founded_year.integer, website.text, created_at.timestamptz )\nCREATE TABLE gaming_technology.game_sessions (\n    session_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game session\n    player_id uuid NOT NULL, -- FK linking to the players table\n    game_id uuid NOT NULL, -- FK linking to the games table\n    server_id uuid, -- FK linking to the servers table (nullable for single-player)\n    start_time timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the session began\n    end_time timestamp with time zone, -- when the session ended (null if ongoing)\n    duration_seconds integer, -- calculated duration of the session in seconds\n    score integer, -- player's score for the session, if applicable\n    session_data jsonb, -- flexible field for session-specific info (e.g., map played, character used)\n    PRIMARY KEY (session_id)\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id),\n    -- FOREIGN KEY (server_id) REFERENCES gaming_technology.servers(server_id)\n)\nCREATE TABLE gaming_technology.servers ( server_id uuid, game_id uuid, server_name text, region text, ip_address text, port integer, current_players integer, max_players integer, status text, last_heartbeat timestamp with time zone )\nCREATE TABLE gaming_technology.in_game_items (\n    item_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the item definition\n    game_id uuid NOT NULL, -- FK linking to the game this item belongs to\n    item_name character varying(150) NOT NULL, -- name of the item\n    item_type character varying(50) NOT NULL, -- type (e.g., Cosmetic, Consumable, Weapon, Armor)\n    description text, -- description of the item\n    rarity character varying(30), -- item rarity (e.g., Common, Rare, Epic, Legendary)\n    cost_currency character varying(10), -- currency code if purchasable (e.g., USD, EUR, GOLD)\n    cost_amount numeric(12, 2), -- price if purchasable\n    attributes jsonb, -- flexible field for item stats or properties\n    PRIMARY KEY (item_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "Show each player's username and the number of distinct games they have played sessions on."}, {"role": "assistant", "content": "SELECT\n  p.username,\n  COUNT(DISTINCT gs.game_id) AS games_played\nFROM gaming_technology.players p\nJOIN gaming_technology.game_sessions gs\n  ON p.player_id = gs.player_id\nGROUP BY p.username;"}, {"role": "user", "content": "Now include each player's total number of achievements unlocked."}, {"role": "assistant", "content": "SELECT\n  p.username,\n  COUNT(DISTINCT gs.game_id) AS games_played,\n  COUNT(pa.achievement_id)      AS achievements_unlocked\nFROM gaming_technology.players p\nJOIN gaming_technology.game_sessions gs\n  ON p.player_id = gs.player_id\nLEFT JOIN gaming_technology.player_achievements pa\n  ON p.player_id = pa.player_id\nGROUP BY p.username;"}, {"role": "user", "content": "Exclude players who have played fewer than 3 games or have not unlocked any achievements."}, {"role": "assistant", "content": "SELECT\n  p.username,\n  COUNT(DISTINCT gs.game_id) AS games_played,\n  COUNT(pa.achievement_id)      AS achievements_unlocked\nFROM gaming_technology.players p\nJOIN gaming_technology.game_sessions gs\n  ON p.player_id = gs.player_id\nLEFT JOIN gaming_technology.player_achievements pa\n  ON p.player_id = pa.player_id\nGROUP BY p.username\nHAVING COUNT(DISTINCT gs.game_id) >= 3\n   AND COUNT(pa.achievement_id) > 0;"}, {"role": "user", "content": "Also include the first session start_time as first_play and the first achievement unlocked date as first_achievement."}, {"role": "assistant", "content": "SELECT\n  p.username,\n  COUNT(DISTINCT gs.game_id)      AS games_played,\n  COUNT(pa.achievement_id)         AS achievements_unlocked,\n  MIN(gs.start_time)               AS first_play,\n  MIN(pa.unlocked_at)              AS first_achievement\nFROM gaming_technology.players p\nJOIN gaming_technology.game_sessions gs\n  ON p.player_id = gs.player_id\nLEFT JOIN gaming_technology.player_achievements pa\n  ON p.player_id = pa.player_id\nGROUP BY p.username\nHAVING COUNT(DISTINCT gs.game_id) >= 3\n   AND COUNT(pa.achievement_id) > 0;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.players ( player_id uuid NOT NULL DEFAULT gen_random_uuid(), username character varying(100) NOT NULL UNIQUE, email character varying(255) NOT NULL UNIQUE, password_hash text NOT NULL, registration_date timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, last_login timestamp with time zone, country_code character(2), status character varying(20) NOT NULL DEFAULT 'active', profile_data jsonb, PRIMARY KEY (player_id) )\nCREATE 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 )\nCREATE TABLE gaming_technology.game_sessions ( session_id uuid NOT NULL DEFAULT gen_random_uuid(), player_id uuid NOT NULL, game_id uuid NOT NULL, server_id uuid, start_time timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, end_time timestamp with time zone, duration_seconds integer, score integer, session_data jsonb, PRIMARY KEY (session_id) )\nCREATE TABLE gaming_technology.servers ( server_id uuid PRIMARY KEY, game_id uuid, server_name text, region text, ip_address text, port int, current_players int, max_players int, status text, last_heartbeat timestamptz )\nCREATE TABLE gaming_technology.achievements ( achievement_id.uuid, game_id.uuid, name.text, description.text, icon_url.text, points.integer, hidden.boolean )\nCREATE TABLE gaming_technology.player_achievements ( player_achievement_id uuid PRIMARY KEY, player_id uuid, achievement_id uuid, unlocked_at timestamptz )\nCREATE TABLE gaming_technology.player_inventory ( inventory_id uuid PRIMARY KEY, player_id uuid, item_id uuid, quantity int, acquired_at timestamptz, instance_data jsonb )\n"}
{"conversations": [{"role": "user", "content": "Can you list all SUI coins with 'active' status and their owner addresses and balances?"}, {"role": "assistant", "content": "SELECT object_id, coin_type, owner, balance\nFROM sui_coins\nWHERE status = 'active';"}, {"role": "user", "content": "Add the coin symbol and name from the sui_coins_metadata table."}, {"role": "assistant", "content": "SELECT sc.object_id, sc.coin_type, sc.owner, sc.balance, scm.symbol, scm.name\nFROM sui_coins sc\nLEFT JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type\nWHERE sc.status = 'active';"}, {"role": "user", "content": "Only include coins where the description mentions 'utility'."}, {"role": "assistant", "content": "SELECT sc.object_id, sc.coin_type, sc.owner, sc.balance, scm.symbol, scm.name\nFROM sui_coins sc\nLEFT JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type\nWHERE sc.status = 'active' AND scm.description ILIKE '%utility%';"}, {"role": "user", "content": "Limit the output to the top 10 coins sorted by balance descending."}, {"role": "assistant", "content": "SELECT sc.object_id, sc.coin_type, sc.owner, sc.balance, scm.symbol, scm.name\nFROM sui_coins sc\nLEFT JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type\nWHERE sc.status = 'active' AND scm.description ILIKE '%utility%'\nORDER BY CAST(sc.balance AS BIGINT) DESC\nLIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE erc1155_approval_for_all ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash varchar, log_index integer, contract_address varchar )\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk integer )\nCREATE TABLE nft_holders ( block_number bigint, contract_address varchar, wallet_address varchar, token_id varchar, contract_type varchar, amount varchar, pk varchar )\nCREATE TABLE nft_holder_historical ( block_number bigint, contract_address varchar, wallet_address varchar, token_id varchar, contract_type varchar, amount varchar, pk integer )\nCREATE TABLE sui_coins ( object_id varchar, status varchar, coin_type varchar, balance varchar, owner varchar )\nCREATE TABLE sui_coins_metadata ( object_id varchar, coin_type varchar, status varchar, decimals bigint, description varchar, icon_url varchar, symbol varchar, name varchar )\nCREATE TABLE sui_nfts ( object_id varchar, status varchar, collection_type varchar, package_id varchar, previous_transaction varchar, display varchar, owner varchar, name varchar )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE token_prices ( uuid varchar, blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE token_prices_latest ( blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash varchar, log_index integer, contract_address varchar, pk integer )\nCREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE token_balances_bitcoin ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply varchar, amount varchar )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "How many diagnoses does each status have grouped by is_chronic flag?"}, {"role": "assistant", "content": "SELECT is_chronic, status, COUNT(*) AS count FROM healthcare.diagnoses GROUP BY is_chronic, status;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.diagnoses ( diagnosis_id text, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )\n"}
{"conversations": [{"role": "user", "content": "Get all non-smoking rooms with status 'Available'."}, {"role": "assistant", "content": "SELECT room_id, property_id, room_number, floor\nFROM hospitality_technology.rooms\nWHERE is_smoking = FALSE\n  AND status = 'Available';"}, {"role": "user", "content": "Now include the property_name for each room."}, {"role": "assistant", "content": "SELECT r.room_id, r.room_number, p.property_name, r.floor\nFROM hospitality_technology.rooms r\nJOIN hospitality_technology.properties p\n  ON r.property_id = p.property_id\nWHERE r.is_smoking = FALSE\n  AND r.status = 'Available';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties ( property_id text PRIMARY KEY, property_name text, address_line1 text, address_line2 text, city text, state_province text, postal_code text, country_code text, phone_number text, email_address text, property_type text, star_rating numeric, timezone text, manager_staff_id text, created_at timestamp, updated_at timestamp )\nCREATE TABLE hospitality_technology.rooms ( room_id text PRIMARY KEY, property_id text, room_number text, room_type_id text, floor int, status text, is_smoking boolean, features text, current_condition text, last_cleaned_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "For each driver, show their driver_id, first_name, last_name, along with any other driver whose license_expiry_date is earlier than theirs."}, {"role": "assistant", "content": "SELECT d1.driver_id       AS driver_id,\n       d1.first_name,\n       d1.last_name,\n       d2.driver_id       AS earlier_driver_id,\n       d2.license_expiry_date AS earlier_expiry_date\nFROM transportation.drivers d1\nJOIN transportation.drivers d2\n  ON d2.license_expiry_date < d1.license_expiry_date;"}, {"role": "user", "content": "Exclude pairs where the two expiry dates are not in the same calendar year."}, {"role": "assistant", "content": "SELECT d1.driver_id       AS driver_id,\n       d1.first_name,\n       d1.last_name,\n       d2.driver_id       AS earlier_driver_id,\n       d2.license_expiry_date AS earlier_expiry_date\nFROM transportation.drivers d1\nJOIN transportation.drivers d2\n  ON d2.license_expiry_date < d1.license_expiry_date\n     AND EXTRACT(YEAR FROM d1.license_expiry_date) = EXTRACT(YEAR FROM d2.license_expiry_date);"}, {"role": "user", "content": "Also only include pairs where the difference between their expiry dates is more than 30 days."}, {"role": "assistant", "content": "SELECT d1.driver_id       AS driver_id,\n       d1.first_name,\n       d1.last_name,\n       d2.driver_id       AS earlier_driver_id,\n       d2.license_expiry_date AS earlier_expiry_date,\n       DATE_PART('day', d1.license_expiry_date - d2.license_expiry_date) AS days_difference\nFROM transportation.drivers d1\nJOIN transportation.drivers d2\n  ON d2.license_expiry_date < d1.license_expiry_date\n     AND EXTRACT(YEAR FROM d1.license_expiry_date) = EXTRACT(YEAR FROM d2.license_expiry_date)\nWHERE d1.license_expiry_date - d2.license_expiry_date > INTERVAL '30 days';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.drivers ( driver_id.text, 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 )\n"}
{"conversations": [{"role": "user", "content": "What are the personal contact details of the staff member associated with staff_id 'STAFF789' who worked on a specific maintenance record?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide personal contact details of staff members as this information is not stored in the maintenance_records table and is outside the scope of the available data."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.maintenance_records ( record_id text, asset_id text, asset_type text, maintenance_type text, staff_id text, start_datetime timestamp, end_datetime timestamp, description text, cost numeric, status text )\n"}
{"conversations": [{"role": "user", "content": "List all guests with their loyalty_member_id and communication consent status."}, {"role": "assistant", "content": "SELECT guest_id,\n       first_name,\n       last_name,\n       loyalty_member_id,\n       communication_consent\nFROM hospitality_technology.guests;"}, {"role": "user", "content": "Actually, only include guests who have communication_consent = true and a non-null loyalty_member_id."}, {"role": "assistant", "content": "SELECT guest_id,\n       first_name,\n       last_name,\n       loyalty_member_id,\n       communication_consent\nFROM hospitality_technology.guests\nWHERE communication_consent = true\n  AND loyalty_member_id IS NOT NULL;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.guests ( guest_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, email character varying(255) UNIQUE, phone_number character varying(30), date_of_birth date, address_line1 character varying(255), city character varying(100), state_province character varying(100), postal_code character varying(20), country_code character varying(3), preferences text, loyalty_member_id character varying(64) UNIQUE, communication_consent boolean DEFAULT true, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (guest_id) )\n"}
{"conversations": [{"role": "user", "content": "Show all reviews with the guest's ID, review comment, and the full name of the staff member who responded."}, {"role": "assistant", "content": "SELECT r.review_id, r.guest_id, r.comment, s.first_name AS response_staff_first_name, s.last_name AS response_staff_last_name\nFROM hospitality_technology.reviews r\nLEFT JOIN hospitality_technology.staff s ON r.response_staff_id = s.staff_id;"}, {"role": "user", "content": "Can you include the property name as well?"}, {"role": "assistant", "content": "SELECT r.review_id, r.guest_id, r.comment, p.property_name, s.first_name AS response_staff_first_name, s.last_name AS response_staff_last_name\nFROM hospitality_technology.reviews r\nJOIN hospitality_technology.properties p ON r.property_id = p.property_id\nLEFT JOIN hospitality_technology.staff s ON r.response_staff_id = s.staff_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties ( property_id text PRIMARY KEY, property_name text, address_line1 text, address_line2 text, city text, state_province text, postal_code text, country_code text, phone_number text, email_address text, property_type text, star_rating numeric, timezone text, manager_staff_id text, created_at timestamp, updated_at timestamp )\nCREATE TABLE hospitality_technology.staff ( staff_id text, property_id text, first_name text, last_name text, position text, work_email text, work_phone text, hire_date date, termination_date date, is_active boolean, access_level integer, manager_id text, created_at timestamp )\nCREATE TABLE hospitality_technology.reviews ( review_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, reservation_id character varying(64) UNIQUE, guest_id character varying(64) NOT NULL, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source character varying(100), review_date timestamp with time zone NOT NULL DEFAULT current_timestamp, is_public boolean DEFAULT true, staff_response text, response_staff_id character varying(64), response_date timestamp with time zone, PRIMARY KEY (review_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (response_staff_id) REFERENCES hospitality_technology.staff(staff_id) )\n"}
{"conversations": [{"role": "user", "content": "Can you show me the total number of passengers registered in the database?"}, {"role": "assistant", "content": "db.passengers.countDocuments({})"}], "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. \n##Table Structure\n// db.createCollection('passengers')\n// Optional: db.passengers.createIndex({ passenger_id: 1 }, { unique: true })\n// Optional: db.passengers.createIndex({ email: 1 }, { unique: true, sparse: true })\n// Optional: db.passengers.createIndex({ phone_number: 1 }, { unique: true, sparse: true })\n{\n  _id: ObjectId(),\n  passenger_id: \"pass_pqr\", // String (unique)\n  first_name: \"Alice\", // String\n  last_name: \"Smith\", // String\n  email: \"alice.smith@example.com\", // String (unique, sparse)\n  phone_number: \"+15551234567\", // String (unique, sparse)\n  date_of_birth: ISODate(\"1990-03-20\"), // Date\n  loyalty_program_id: \"LOYALTY123\", // String\n  created_at: ISODate(\"2023-02-01T11:00:00Z\") // Date\n}\n"}
{"conversations": [{"role": "user", "content": "Show me all policies that expired in the last 60 days, along with their product IDs and premium amounts."}, {"role": "assistant", "content": "SELECT policy_id, product_id, premium_amount FROM insurance.policies WHERE status = 'expired' AND end_date >= CURRENT_DATE - INTERVAL '60 days' AND end_date <= CURRENT_DATE;"}, {"role": "user", "content": "Now include only policies that had a deductible of $1000 or more."}, {"role": "assistant", "content": "SELECT policy_id, product_id, premium_amount, deductible FROM insurance.policies WHERE status = 'expired' AND end_date >= CURRENT_DATE - INTERVAL '60 days' AND end_date <= CURRENT_DATE AND deductible >= 1000;"}, {"role": "user", "content": "I also want to see the count of such expired policies per product ID."}, {"role": "assistant", "content": "SELECT product_id, COUNT(*) as policy_count FROM insurance.policies WHERE status = 'expired' AND end_date >= CURRENT_DATE - INTERVAL '60 days' AND end_date <= CURRENT_DATE AND deductible >= 1000 GROUP BY product_id ORDER BY policy_count DESC;"}, {"role": "user", "content": "Finally, show me the average premium amount for these expired high-deductible policies grouped by product ID."}, {"role": "assistant", "content": "SELECT product_id, AVG(premium_amount) as avg_premium FROM insurance.policies WHERE status = 'expired' AND end_date >= CURRENT_DATE - INTERVAL '60 days' AND end_date <= CURRENT_DATE AND deductible >= 1000 GROUP BY product_id ORDER BY avg_premium DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.policies ( policy_id text PRIMARY KEY, 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 )\n"}
{"conversations": [{"role": "user", "content": "What is the current job satisfaction level or feedback from staff members working at a specific train station?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information on job satisfaction levels or feedback from staff members as this data is not included in the staff table."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.staff ( staff_id.text, first_name.text, last_name.text, role.text, primary_station_id.text, employee_number.text, hire_date.date, contact_email.text, contact_phone.text, is_active.boolean )\n"}
{"conversations": [{"role": "user", "content": "Show me the invoice number and total amount for each invoice, along with the number and name of the case it belongs to."}, {"role": "assistant", "content": "SELECT T1.invoice_number, T1.total_amount, T2.case_number, T2.case_name FROM invoices AS T1 JOIN cases AS T2 ON T1.case_id = T2.case_id;"}, {"role": "user", "content": "Refine this to only include invoices with a status of 'Overdue' or 'Unpaid'."}, {"role": "assistant", "content": "SELECT T1.invoice_number, T1.total_amount, T2.case_number, T2.case_name FROM invoices AS T1 JOIN cases AS T2 ON T1.case_id = T2.case_id WHERE T1.status = 'Overdue' OR T1.status = 'Unpaid';"}, {"role": "user", "content": "Also include the invoice due date and order the results by due date ascending."}, {"role": "assistant", "content": "SELECT T1.invoice_number, T1.total_amount, T1.due_date, T2.case_number, T2.case_name FROM invoices AS T1 JOIN cases AS T2 ON T1.case_id = T2.case_id WHERE T1.status = 'Overdue' OR T1.status = 'Unpaid' ORDER BY T1.due_date ASC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.law_firms ( firm_id text, firm_name text, address text, phone text, website text, founded_date date, managing_partner_id text )\nCREATE TABLE legal_services.cases ( case_id character varying(64) NOT NULL, case_number character varying(100) UNIQUE, case_name text NOT NULL, client_id character varying(64) NOT NULL, lead_lawyer_id character varying(64) NOT NULL, case_type character varying(100) NOT NULL, status character varying(50) NOT NULL, date_opened timestamp NOT NULL, date_closed timestamp, description text, court_jurisdiction character varying(128), PRIMARY KEY (case_id) )\nCREATE TABLE legal_services.invoices ( invoice_id text PRIMARY KEY, invoice_number text UNIQUE, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show me all wallet addresses that hold more than 1000 of any ERC1155 token, along with the token ID and amount."}, {"role": "assistant", "content": "SELECT wallet_address, token_id, amount FROM nft_holders WHERE contract_type = 'ERC1155' AND CAST(amount AS decimal) > 1000;"}, {"role": "user", "content": "Can you join this with the nft_metadata table to include the name and image URI of each token?"}, {"role": "assistant", "content": "SELECT nh.wallet_address, nh.token_id, nh.amount, nm.name, nm.image_uri FROM nft_holders nh JOIN nft_metadata nm ON nh.contract_address = nm.contract_address AND nh.token_id = nm.token_id WHERE nh.contract_type = 'ERC1155' AND CAST(nh.amount AS decimal) > 1000;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE erc1155_approval_for_all (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction\n    transaction_index integer NOT NULL, -- Index of the transaction within the block\n    transaction_hash varchar(66) NOT NULL, -- Transaction hash\n    log_index integer NOT NULL, -- Log index\n    contract_address varchar(42) NOT NULL  -- Event contract address\n)\nCREATE TABLE erc20_balances ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_holders (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    contract_address varchar NOT NULL, -- Event contract address\n    wallet_address varchar NOT NULL, -- The wallet address for the contract(with bloom filter)\n    token_id varchar NOT NULL, -- NFT token id\n    contract_type varchar NOT NULL, -- NFT contract type\n    amount varchar NOT NULL, -- Number of held NFTs\n    pk varchar NOT NULL  -- The last string partition of the contract.\n)\nCREATE TABLE nft_holder_historical ( block_number bigint, contract_address text, wallet_address text, token_id text, contract_type text, amount text, pk integer )\nCREATE TABLE sui_coins_metadata ( object_id.text, coin_type.text, status.text, decimals.bigint, description.text, icon_url.text, symbol.text, name.text )\nCREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE token_prices ( uuid.text, blockchain.text, address.text, decimals.bigint, symbol.text, price.real, timestamp.timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash text, log_index integer, contract_address text, pk integer )\nCREATE TABLE token_balances ( block_number.bigint, block_timestamp.timestamp, tick.text, wallet_address.text, total_supply.decimal, amount.decimal )\nCREATE TABLE token_info (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    tick varchar NOT NULL, -- Token tick\n    max_supply decimal(38,0) NOT NULL, -- Max supply\n    lim decimal(38,0) NOT NULL, -- Limit of each mint\n    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint\n    dec integer NOT NULL, -- Decimal for minimum divie\n    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)\n)\nCREATE TABLE token_balances_bitcoin ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply varchar, amount varchar )\nCREATE TABLE token_info_bitcoin ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar(255) NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, log_index integer, type text, tick text, id text, amt decimal, from_address text, to_address text )\nCREATE TABLE token_balances_avalanche ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar(20) NOT NULL, wallet_address varchar(42) NOT NULL, total_supply decimal(38,0) NOT NULL, amount decimal(38,0) NOT NULL )\n"}
{"conversations": [{"role": "user", "content": "How many distinct users have sent messages in each conversation? Return conversation_id and user_count."}, {"role": "assistant", "content": "SELECT conversation_id,\n       COUNT(DISTINCT sender_user_id) AS user_count\nFROM social_media.messages\nGROUP BY conversation_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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) )\nCREATE TABLE social_media.likes ( like_id text PRIMARY KEY, user_id text, post_id text, comment_id text, created_at timestamp )\nCREATE 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) )\nCREATE TABLE social_media.messages (\n    message_id character varying(64) NOT NULL, -- unique identifier for the message\n    conversation_id character varying(64) NOT NULL, -- identifier for the conversation thread (FK to conversations.conversation_id)\n    sender_user_id character varying(64) NOT NULL, -- identifier of the sender (FK to users.user_id)\n    content text, -- textual content of the message\n    media_url text, -- URL to attached media (image/video)\n    media_type character varying(20), -- type of media ('image', 'video', null)\n    sent_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when message was sent\n    read_at timestamp, -- timestamp when message was read by recipient(s)\n    PRIMARY KEY (message_id)\n)\nCREATE TABLE social_media.conversation_participants ( participant_id.text, conversation_id.text, user_id.text, joined_at.timestamp, last_read_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show each service's name along with the total number of appointments scheduled and the number of unique locations these appointments are scheduled at."}, {"role": "assistant", "content": "SELECT s.service_name, COUNT(a.application_id) AS appointment_count, COUNT(DISTINCT ap.location_id) AS unique_location_count\nFROM government_services.services s\nJOIN government_services.applications a ON s.service_id = a.service_id\nJOIN government_services.appointments ap ON a.application_id = ap.application_id\nGROUP BY s.service_name;"}, {"role": "user", "content": "I got an error: relation 'appointments' does not exist."}, {"role": "assistant", "content": "-- The appointments table is not present in the provided schema. If you want to count by another join, perhaps by documents or payments, please specify.\n-- Alternatively, do you want appointment information replaced with application submissions per service and their associated location from service_locations?\nSELECT s.service_name, COUNT(a.application_id) AS application_count, COUNT(DISTINCT sl.location_id) AS unique_location_count\nFROM government_services.services s\nJOIN government_services.applications a ON s.service_id = a.service_id\nJOIN government_services.service_locations sl ON s.agency_id = sl.agency_id\nGROUP BY s.service_name;"}, {"role": "user", "content": "Show only those services where application_count is greater than 50."}, {"role": "assistant", "content": "SELECT s.service_name, COUNT(a.application_id) AS application_count, COUNT(DISTINCT sl.location_id) AS unique_location_count\nFROM government_services.services s\nJOIN government_services.applications a ON s.service_id = a.service_id\nJOIN government_services.service_locations sl ON s.agency_id = sl.agency_id\nGROUP BY s.service_name\nHAVING COUNT(a.application_id) > 50;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens (\n    citizen_id character varying(64) NOT NULL,  -- unique identifier for the citizen\n    national_id_number character varying(128) NOT NULL UNIQUE, -- official national identification number\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    date_of_birth date NOT NULL,\n    gender character varying(20),\n    primary_address text NOT NULL, -- full primary residential address\n    contact_email character varying(128) UNIQUE,\n    contact_phone character varying(32),\n    registration_date timestamp NOT NULL, -- when the citizen profile was created\n    is_verified boolean DEFAULT false, -- whether identity has been officially verified\n    PRIMARY KEY (citizen_id)\n)\nCREATE 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 )\nCREATE TABLE government_services.services ( service_id text PRIMARY KEY, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days int, is_active boolean, online_application_url text )\nCREATE TABLE government_services.applications ( application_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, service_id character varying(64) NOT NULL, submitted_at timestamp NOT NULL, status character varying(50) NOT NULL, last_updated_at timestamp NOT NULL, assigned_employee_id character varying(64), decision_date date, notes text, reference_number character varying(100) UNIQUE, PRIMARY KEY (application_id) )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE government_services.service_locations (\n    location_id character varying(64) NOT NULL, -- unique identifier for the physical location\n    agency_id character varying(64) NOT NULL, -- FK to agencies table\n    location_name character varying(200), -- e.g., Downtown DMV Office\n    address text NOT NULL,\n    city character varying(100),\n    state character varying(50),\n    postal_code character varying(20),\n    latitude numeric(9, 6),\n    longitude numeric(9, 6),\n    operating_hours text, -- description of opening times\n    contact_phone character varying(32),\n    is_accessible boolean, -- accessibility information (e.g., wheelchair access)\n    PRIMARY KEY (location_id)\n)\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Find pairs of citizens who share the same gender but registered in different years. Show each citizen's first and last name along with their registration year."}, {"role": "assistant", "content": "SELECT c1.first_name AS first_name_1,\n       c1.last_name  AS last_name_1,\n       EXTRACT(YEAR FROM c1.registration_date) AS reg_year_1,\n       c2.first_name AS first_name_2,\n       c2.last_name  AS last_name_2,\n       EXTRACT(YEAR FROM c2.registration_date) AS reg_year_2\nFROM government_services.citizens c1\nJOIN government_services.citizens c2\n  ON c1.gender = c2.gender\n AND EXTRACT(YEAR FROM c1.registration_date) <> EXTRACT(YEAR FROM c2.registration_date)\n AND c1.citizen_id < c2.citizen_id;"}, {"role": "user", "content": "Exclude any pairs where either citizen is not verified."}, {"role": "assistant", "content": "SELECT c1.first_name AS first_name_1,\n       c1.last_name  AS last_name_1,\n       EXTRACT(YEAR FROM c1.registration_date) AS reg_year_1,\n       c2.first_name AS first_name_2,\n       c2.last_name  AS last_name_2,\n       EXTRACT(YEAR FROM c2.registration_date) AS reg_year_2\nFROM government_services.citizens c1\nJOIN government_services.citizens c2\n  ON c1.gender = c2.gender\n AND EXTRACT(YEAR FROM c1.registration_date) <> EXTRACT(YEAR FROM c2.registration_date)\n AND c1.citizen_id < c2.citizen_id\nWHERE c1.is_verified = TRUE\n  AND c2.is_verified = TRUE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Count the number of events for each hour of the day based on the emitted_at timestamp."}, {"role": "assistant", "content": "SELECT EXTRACT(HOUR FROM emitted_at) AS event_hour, COUNT(*) AS event_count FROM web3.events GROUP BY event_hour ORDER BY event_hour;"}, {"role": "user", "content": "Actually, only show hours with more than 100 events."}, {"role": "assistant", "content": "SELECT EXTRACT(HOUR FROM emitted_at) AS event_hour, COUNT(*) AS event_count FROM web3.events GROUP BY event_hour HAVING COUNT(*) > 100 ORDER BY event_hour;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.events ( event_id character varying(64) NOT NULL, contract_id character varying(64) NOT NULL, event_name character varying(128) NOT NULL, data text NOT NULL, emitted_at timestamp NOT NULL, transaction_id character varying(64) NOT NULL, log_index integer NOT NULL, PRIMARY KEY (event_id) )\n"}
{"conversations": [{"role": "user", "content": "List all invoices that were paid within 7 days of their issue date. Show invoice number, issue date, payment date, and total amount."}, {"role": "assistant", "content": "SELECT invoice_number, issue_date, payment_date, total_amount FROM legal_services.invoices WHERE status = 'Paid' AND payment_date IS NOT NULL AND (payment_date::DATE - issue_date) <= 7;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all users who have never followed anyone, showing their username, full name, email, and account creation date."}, {"role": "assistant", "content": "SELECT u.username,\n       u.full_name,\n       u.email,\n       u.created_at\nFROM social_media.users AS u\nLEFT JOIN social_media.follows AS f\n  ON u.user_id = f.follower_user_id\nWHERE f.follow_id IS NULL;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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) )\nCREATE TABLE social_media.comments ( comment_id.text, post_id.text, user_id.text, parent_comment_id.text, content.text, created_at.timestamp, updated_at.timestamp )\nCREATE TABLE social_media.likes ( like_id text PRIMARY KEY, user_id text, post_id text, comment_id text, created_at timestamp )\nCREATE TABLE social_media.follows (\n    follow_id character varying(64) NOT NULL, -- unique identifier for the follow relationship\n    follower_user_id character varying(64) NOT NULL, -- identifier of the user who is following (FK to users.user_id)\n    following_user_id character varying(64) NOT NULL, -- identifier of the user being followed (FK to users.user_id)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of when the follow started\n    PRIMARY KEY (follow_id),\n    CONSTRAINT unique_follow UNIQUE (follower_user_id, following_user_id) -- prevent duplicate follows\n)\nCREATE 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) )\nCREATE TABLE social_media.post_hashtags ( post_hashtag_id text PRIMARY KEY, post_id text, hashtag_id text )\nCREATE TABLE social_media.conversations ( conversation_id.text, created_at.timestamp, last_message_at.timestamp, is_group_chat.boolean, group_name.text )\nCREATE TABLE social_media.conversation_participants ( participant_id.text, conversation_id.text, user_id.text, joined_at.timestamp, last_read_at.timestamp )\nCREATE 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 )\nCREATE TABLE social_media.user_settings ( setting_id.text, user_id.text, theme.text, email_notifications_enabled.boolean, push_notifications_enabled.boolean, private_profile.boolean, updated_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "List the names of employees and the agency they work for who have scheduled at least one appointment. Show the employee's first name, last name, and agency_id."}, {"role": "assistant", "content": "SELECT DISTINCT e.first_name, e.last_name, e.agency_id\nFROM government_services.employees e\nJOIN government_services.appointments a ON e.employee_id = a.employee_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.services ( service_id text, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days integer, is_active boolean, online_application_url text )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE government_services.employees ( employee_id text, agency_id text, first_name text, last_name text, job_title text, department text, work_email text, work_phone text, hire_date date, termination_date date, access_level text, manager_employee_id text )\nCREATE TABLE government_services.appointments ( appointment_id text, citizen_id text, employee_id text, location_id text, service_id text, scheduled_start_time timestamp, scheduled_end_time timestamp, purpose text, status text, booking_method text, created_at timestamp, notes text )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Find all wallets created by users in the last 7 days along with any tokens that have a total supply greater than 10 million, showing the wallet address and token details."}, {"role": "assistant", "content": "SELECT w.address AS wallet_address, t.token_name, t.token_symbol, t.total_supply, t.contract_address FROM web3.wallets w JOIN web3.tokens t ON t.total_supply > 10000000 WHERE w.created_at >= CURRENT_DATE - INTERVAL '7 days';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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) )\nCREATE TABLE web3.wallets ( wallet_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, address character varying(128) NOT NULL, private_key text NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (wallet_id) )\n"}
{"conversations": [{"role": "user", "content": "What is the current market price of a Boeing 737 MAX aircraft?"}, {"role": "assistant", "content": "I'm sorry, but I don't have access to the current market price of aircraft models. The data I have is limited to technical specifications and general information about aircraft models such as passenger capacity, range, and status. For pricing information, you may need to consult with manufacturers or industry reports."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE manufacturing.aircraft_models (\n    model_id character varying(64) NOT NULL,  -- unique identifier for the aircraft model\n    model_name character varying(128) NOT NULL, -- commercial name of the model (e.g., 737 MAX, A320neo)\n    manufacturer character varying(128) NOT NULL, -- manufacturer name (e.g., Boeing, Airbus)\n    passenger_capacity integer, -- typical passenger capacity\n    max_range_km integer, -- maximum flight range in kilometers\n    engine_type character varying(100), -- type of engines used\n    wingspan_m numeric(6,2), -- wingspan in meters\n    status character varying(50) NOT NULL, -- e.g., 'In Production', 'Development', 'Discontinued'\n    first_flight_date date, -- date of the model's first flight\n    PRIMARY KEY (model_id)\n)\n"}
{"conversations": [{"role": "user", "content": "For each event, display its event_id, the event_id of the previous event in the same transaction (if any), and the log_index of both events."}, {"role": "assistant", "content": "SELECT curr.event_id   AS current_event_id,\n       prev.event_id   AS previous_event_id,\n       curr.log_index  AS current_log_index,\n       prev.log_index  AS previous_log_index,\n       curr.transaction_id\nFROM web3.events curr\nLEFT JOIN web3.events prev\n  ON curr.transaction_id = prev.transaction_id\n AND curr.log_index = prev.log_index + 1;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.events ( event_id character varying(64) NOT NULL, contract_id character varying(64) NOT NULL, event_name character varying(128) NOT NULL, data text NOT NULL, emitted_at timestamp NOT NULL, transaction_id character varying(64) NOT NULL, log_index integer NOT NULL, PRIMARY KEY (event_id) )\n"}
{"conversations": [{"role": "user", "content": "For each user with at least two wallets, calculate the average time difference in hours between consecutive wallet creations. Return user_id and avg_diff_hours."}, {"role": "assistant", "content": "SELECT user_id, AVG(EXTRACT(EPOCH FROM (created_at - prev_created)) / 3600) AS avg_diff_hours FROM (SELECT user_id, created_at, LAG(created_at) OVER (PARTITION BY user_id ORDER BY created_at) AS prev_created FROM web3.wallets) t WHERE prev_created IS NOT NULL GROUP BY user_id;"}, {"role": "user", "content": "Actually, restrict the results to users whose avg_diff_hours is less than 24 hours and sort by avg_diff_hours ascending."}, {"role": "assistant", "content": "WITH diffs AS (SELECT user_id, EXTRACT(EPOCH FROM (created_at - prev_created)) / 3600 AS diff_hours FROM (SELECT user_id, created_at, LAG(created_at) OVER (PARTITION BY user_id ORDER BY created_at) AS prev_created FROM web3.wallets) sub WHERE prev_created IS NOT NULL) SELECT user_id, AVG(diff_hours) AS avg_diff_hours FROM diffs GROUP BY user_id HAVING AVG(diff_hours) < 24 ORDER BY avg_diff_hours;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.contracts (\n    contract_id character varying(64) NOT NULL,  -- unique identifier for the contract\n    address character varying(128) NOT NULL, -- address of the deployed contract\n    abi text NOT NULL, -- application binary interface of the contract\n    bytecode text NOT NULL, -- bytecode of the contract\n    deployer_address character varying(128) NOT NULL, -- address of the deployer\n    deployed_at timestamp NOT NULL, -- time when the contract was deployed\n    network_id character varying(64) NOT NULL, -- identifier of the network where the contract is deployed\n    status character varying(32) NOT NULL, -- status of the contract (e.g., active, deprecated)\n    PRIMARY KEY (contract_id)\n)\nCREATE TABLE web3.transactions (\n    transaction_id character varying(64) NOT NULL,  -- unique identifier for the transaction\n    from_address character varying(128) NOT NULL, -- address of the sender\n    to_address character varying(128), -- address of the receiver (can be null for contract deployment)\n    value numeric(38,14) NOT NULL, -- value transferred\n    gas_used integer NOT NULL, -- amount of gas used by the transaction\n    gas_price numeric(38,14) NOT NULL, -- price of gas at the time of the transaction\n    block_number integer NOT NULL, -- block number containing the transaction\n    timestamp timestamp NOT NULL, -- time when the transaction was mined\n    input_data text, -- input data of the transaction (can be null)\n    status character varying(32) NOT NULL, -- status of the transaction (e.g., success, failed)\n    nonce integer NOT NULL, -- nonce of the sender at the time of the transaction\n    PRIMARY KEY (transaction_id)\n)\nCREATE TABLE web3.wallets (\n    wallet_id character varying(64) NOT NULL,  -- unique identifier for the wallet\n    user_id character varying(64) NOT NULL, -- identifier of the user owning the wallet\n    address character varying(128) NOT NULL, -- address of the wallet\n    private_key text NOT NULL, -- private key of the wallet\n    created_at timestamp NOT NULL, -- time when the wallet was created\n    PRIMARY KEY (wallet_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me all cryptocurrency assets that have metadata entries for both 'category' and 'subcategory', along with their corresponding values."}, {"role": "assistant", "content": "SELECT m1.asset_id, m1.value AS category, m2.value AS subcategory FROM trading_platform.metadata m1 JOIN trading_platform.metadata m2 ON m1.asset_id = m2.asset_id JOIN trading_platform.metadata m3 ON m1.asset_id = m3.asset_id WHERE m1.key = 'category' AND m2.key = 'subcategory' AND m3.key = 'asset_type' AND m3.value = 'cryptocurrency';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.users ( user_id text, username text, email text, password_hash text, created_at timestamp )\nCREATE TABLE trading_platform.wallets ( wallet_id.text, user_id.text, address.text, private_key.text, created_at.timestamp )\nCREATE TABLE trading_platform.orders ( order_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, wallet_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, order_type character varying(32) NOT NULL, quantity numeric(38,14) NOT NULL, price numeric(38,14) NOT NULL, status character varying(32) NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (order_id) )\nCREATE TABLE trading_platform.trades ( trade_id character varying(64) NOT NULL, order_id character varying(64) NOT NULL, buyer_id character varying(64) NOT NULL, seller_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, quantity numeric(38,14) NOT NULL, price numeric(38,14) NOT NULL, traded_at timestamp NOT NULL, PRIMARY KEY (trade_id) )\nCREATE TABLE trading_platform.dapps (\n    dapp_id character varying(64) NOT NULL,  -- unique identifier for the DApp\n    name character varying(128) NOT NULL, -- name of the DApp\n    description text NOT NULL, -- description of the DApp\n    url character varying(256) NOT NULL, -- URL of the DApp\n    PRIMARY KEY (dapp_id)\n)\nCREATE TABLE trading_platform.metadata ( metadata_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, key character varying(128) NOT NULL, value text NOT NULL, PRIMARY KEY (metadata_id) )\nCREATE TABLE trading_platform.kyc_audit ( kyc_audit_id text PRIMARY KEY, user_id text, status text, reviewed_at timestamp )\nCREATE TABLE trading_platform.logs (\n    log_id character varying(64) NOT NULL,  -- unique identifier for the log entry\n    user_id character varying(64), -- identifier of the user associated with the log entry\n    action character varying(128) NOT NULL, -- action performed\n    details text NOT NULL, -- details of the action\n    logged_at timestamp NOT NULL, -- time when the log entry was created\n    PRIMARY KEY (log_id)\n)\nCREATE TABLE trading_platform.notifications (\n    notification_id character varying(64) NOT NULL,  -- unique identifier for the notification\n    user_id character varying(64) NOT NULL, -- identifier of the user receiving the notification\n    message text NOT NULL, -- message of the notification\n    sent_at timestamp NOT NULL, -- time when the notification was sent\n    read_at timestamp, -- time when the notification was read\n    PRIMARY KEY (notification_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me the top 5 projects by valuation that completed fundraising rounds in the last 12 months, along with their token symbol and price from the token_basic_info table."}, {"role": "assistant", "content": "SELECT pfr.project_name, pfr.valuation, tbi.token_symbol, tbi.price FROM project_fundraising_record pfr LEFT JOIN token_basic_info tbi ON pfr.project_name = tbi.token_name WHERE pfr.investment_date >= DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH) ORDER BY pfr.valuation DESC LIMIT 5;"}, {"role": "user", "content": "Can you also include the 24-hour trading volume for these projects' tokens and filter to only include projects with valuation over $100 million?"}, {"role": "assistant", "content": "SELECT pfr.project_name, pfr.valuation, tbi.token_symbol, tbi.price, tbi.total_volume FROM project_fundraising_record pfr LEFT JOIN token_basic_info tbi ON pfr.project_name = tbi.token_name WHERE pfr.investment_date >= DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH) AND pfr.valuation > 100000000 ORDER BY pfr.valuation DESC LIMIT 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\n \"CREATE TABLE project_fundraising_record (\",\n    \"id character varying(32) NOT NULL,  -- fundraising record id\",\n    \"project_id character varying(32) NOT NULL, -- the invested project's id\",\n    \"project_name character varying(128) NOT NULL, -- name of the invested project\",\n    \"rounds_name character varying(32), -- name of the fundraising round\",\n    \"investment_value numeric(38,14), -- amount of the fundraising in USD\",\n    \"investment_date character varying(128), -- the date of the investment happened\",\n    \"introduction character varying(128), -- the introduction of the invested project\",\n    \"valuation numeric(38,14), -- the valuation of the project in USD when invested\",\n\nCREATE 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) )\nCREATE TABLE narrative_info ( narrative character varying(512) NOT NULL, -- the id of narrative top_3_coins text, -- the top 3 tokens in the narrative price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour in the narrative price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours in the narrative price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days in the narrative market_cap double precision, -- the market cap of the narrative volume_24h double precision, -- the trade volume of the narrative trend_rank bigint, -- the trending rank of the narrative, value 1 expresses the most popular narrative token_num bigint, -- total token number in the narrative ,PRIMARY KEY (narrative) )\nCREATE TABLE token_dexpool_info ( pair_address character varying(512) NOT NULL, token_name character varying(100) NOT NULL, token_symbol character varying(100) NOT NULL, chain text, price double precision, price_change_percentage_1h double precision, price_change_percentage_6h double precision, price_change_percentage_24h double precision, makers_24h double precision, volume_24h double precision, liquidity double precision, market_cap double precision, trend_rank bigint )\nCREATE TABLE smart_money_profit ( address character varying(100) NOT NULL, rank INT, profit numeric(38,6), roi numeric(38,2), realized_ratio numeric(38,2), most_profit_token character varying(100), last_trade_time character varying(100), chain character varying(100) )\n  \"CREATE TABLE smart_money_token_performance (\",\n    \"token_address character varying(100) NOT NULL, -- the token's address\",\n    \"token_symbol character varying(100), -- the tokens's symbol\",\n    \"pnl numeric(38,2), -- the profit users made on this token\",\n    \"net_flow numeric(38,2), -- the netflow of the token, means the money user spent minus the the money user sold of this token\",\n    \"avg_cost numeric(38,16), -- the average cost price of user spent on this token\",\n    \"price double precision, -- the current price of the token\",\n    \"realized_ratio numeric(10,2), -- the ratio user sold of the token\",\n    \"roi numeric(10,2), -- the roi users made of this token\",\n    \"chain character varying(100), -- the chain that the token resides\",\n    \"PRIMARY KEY (token_address, chain));\",\n\n  \"CREATE TABLE smart_money_token_inflow (\",\n    \"token_address character varying(100) NOT NULL, -- the token's address\",\n    \"token_symbol character varying(100), -- the tokens's symbol\",\n    \"token_amount numeric(38,2), -- the absolute value of the amount if user bought minus  the amount user sold of this token\",\n    \"usd_value numeric(38,2), -- the absolute usd value of the bought token minus sold token\",\n    \"avg_price numeric(38,6), -- the average cost price of user spent on this token\",\n    \"type int, -- the direction of the trade on this token. 1 means buying, 2 means selling\",\n    \"address_amount integer, -- the amount of the user bought this token\",\n    \"narrative character varying(100), -- the category or narrative of the token\",\n    \"chain character varying(100), -- the chain that the token resides\",\n    \",PRIMARY KEY (token_address, chain)\",\n\n"}
{"conversations": [{"role": "user", "content": "Show the name of each agency and whether it operates at least one service location marked as accessible."}, {"role": "assistant", "content": "SELECT T1.agency_name FROM government_services.agencies AS T1 JOIN government_services.service_locations AS T2 ON T1.agency_id = T2.agency_id WHERE T2.is_accessible = TRUE GROUP BY T1.agency_name;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.agencies (\n    agency_id character varying(64) NOT NULL, -- unique identifier for the agency\n    agency_name character varying(255) NOT NULL, -- full name of the government agency\n    jurisdiction_level character varying(50) NOT NULL, -- e.g., Federal, State, County, City\n    primary_contact_email character varying(128),\n    main_phone_number character varying(32),\n    website_url character varying(255),\n    established_date date,\n    parent_agency_id character varying(64), -- FK to self for hierarchical structure\n    PRIMARY KEY (agency_id)\n)\nCREATE TABLE government_services.services (\n    service_id character varying(64) NOT NULL, -- unique identifier for the service\n    agency_id character varying(64) NOT NULL, -- FK to agencies table\n    service_name character varying(255) NOT NULL, -- name of the service (e.g., Driver's License Renewal)\n    description text,\n    category character varying(100), -- e.g., Licensing, Benefits, Taxation, Permits\n    eligibility_criteria text, -- description of who is eligible\n    standard_fee numeric(10, 2) DEFAULT 0.00, -- typical fee for the service\n    average_processing_time_days integer, -- estimated processing time\n    is_active boolean DEFAULT true, -- whether the service is currently offered\n    online_application_url character varying(255),\n    PRIMARY KEY (service_id)\n)\nCREATE TABLE government_services.service_locations (\n    location_id character varying(64) NOT NULL, -- unique identifier for the physical location\n    agency_id character varying(64) NOT NULL, -- FK to agencies table\n    location_name character varying(200), -- e.g., Downtown DMV Office\n    address text NOT NULL,\n    city character varying(100),\n    state character varying(50),\n    postal_code character varying(20),\n    latitude numeric(9, 6),\n    longitude numeric(9, 6),\n    operating_hours text, -- description of opening times\n    contact_phone character varying(32),\n    is_accessible boolean, -- accessibility information (e.g., wheelchair access)\n    PRIMARY KEY (location_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Can you list the number of citizens registered each month in 2024? Please show the month and the citizen count."}, {"role": "assistant", "content": "SELECT TO_CHAR(registration_date, 'YYYY-MM') AS registration_month, COUNT(*) AS citizen_count FROM government_services.citizens WHERE registration_date >= '2024-01-01' AND registration_date < '2025-01-01' GROUP BY registration_month ORDER BY registration_month;"}, {"role": "user", "content": "Now, can you also show the number of verified citizens for each month?"}, {"role": "assistant", "content": "SELECT TO_CHAR(registration_date, 'YYYY-MM') AS registration_month, COUNT(*) AS citizen_count, SUM(CASE WHEN is_verified = true THEN 1 ELSE 0 END) AS verified_citizen_count FROM government_services.citizens WHERE registration_date >= '2024-01-01' AND registration_date < '2025-01-01' GROUP BY registration_month ORDER BY registration_month;"}, {"role": "user", "content": "I see some months with zero verified citizens, but they still show up. Can you exclude months with zero verified citizens from the result?"}, {"role": "assistant", "content": "SELECT registration_month, citizen_count, verified_citizen_count FROM (SELECT TO_CHAR(registration_date, 'YYYY-MM') AS registration_month, COUNT(*) AS citizen_count, SUM(CASE WHEN is_verified = true THEN 1 ELSE 0 END) AS verified_citizen_count FROM government_services.citizens WHERE registration_date >= '2024-01-01' AND registration_date < '2025-01-01' GROUP BY registration_month) sub WHERE verified_citizen_count > 0 ORDER BY registration_month;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id character varying(64) NOT NULL, national_id_number character varying(128) NOT NULL UNIQUE, 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, contact_email character varying(128) UNIQUE, contact_phone character varying(32), registration_date timestamp NOT NULL, is_verified boolean DEFAULT false, PRIMARY KEY (citizen_id) )\n"}
{"conversations": [{"role": "user", "content": "Show me the earliest created smart contract for each creator address."}, {"role": "assistant", "content": "SELECT sc1.contract_id, sc1.creator_address, sc1.timestamp FROM blockchain.smart_contracts sc1 WHERE sc1.timestamp = (SELECT MIN(sc2.timestamp) FROM blockchain.smart_contracts sc2 WHERE sc2.creator_address = sc1.creator_address);"}, {"role": "user", "content": "Now include the total number of contracts each creator has made alongside this information."}, {"role": "assistant", "content": "SELECT sc1.contract_id, sc1.creator_address, sc1.timestamp, (SELECT COUNT(*) FROM blockchain.smart_contracts sc2 WHERE sc2.creator_address = sc1.creator_address) AS total_contracts FROM blockchain.smart_contracts sc1 WHERE sc1.timestamp = (SELECT MIN(sc3.timestamp) FROM blockchain.smart_contracts sc3 WHERE sc3.creator_address = sc1.creator_address);"}, {"role": "user", "content": "Filter this to only show creators who have made at least 10 contracts."}, {"role": "assistant", "content": "SELECT sc1.contract_id, sc1.creator_address, sc1.timestamp, (SELECT COUNT(*) FROM blockchain.smart_contracts sc2 WHERE sc2.creator_address = sc1.creator_address) AS total_contracts FROM blockchain.smart_contracts sc1 WHERE sc1.timestamp = (SELECT MIN(sc3.timestamp) FROM blockchain.smart_contracts sc3 WHERE sc3.creator_address = sc1.creator_address) AND (SELECT COUNT(*) FROM blockchain.smart_contracts sc4 WHERE sc4.creator_address = sc1.creator_address) >= 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE blockchain.smart_contracts ( contract_id.text, creator_address.text, code.text, timestamp.timestamp )\n"}
{"conversations": [{"role": "user", "content": "List each vehicle and the date of its most recent maintenance, including the service type and cost."}, {"role": "assistant", "content": "SELECT vehicle_id, service_type, cost, service_date FROM (SELECT *, ROW_NUMBER() OVER (PARTITION BY vehicle_id ORDER BY service_date DESC) AS rn FROM transportation.maintenance_logs) AS ranked_logs WHERE rn = 1;"}, {"role": "user", "content": "I received an error that 'service_type' does not exist in the outermost query."}, {"role": "assistant", "content": "SELECT vehicle_id, service_date, service_type, cost FROM (SELECT log_id, vehicle_id, service_date, service_type, cost, ROW_NUMBER() OVER (PARTITION BY vehicle_id ORDER BY service_date DESC) AS rn FROM transportation.maintenance_logs) AS ranked_logs WHERE rn = 1;"}, {"role": "user", "content": "Also include the name of the mechanic for each latest maintenance."}, {"role": "assistant", "content": "SELECT vehicle_id, service_date, service_type, cost, mechanic_name FROM (SELECT log_id, vehicle_id, service_date, service_type, cost, mechanic_name, ROW_NUMBER() OVER (PARTITION BY vehicle_id ORDER BY service_date DESC) AS rn FROM transportation.maintenance_logs) AS ranked_logs WHERE rn = 1;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.maintenance_logs ( log_id text, vehicle_id text, service_date date, odometer_reading integer, service_type text, description text, cost numeric, mechanic_name text, next_service_due_date date )\n"}
{"conversations": [{"role": "user", "content": "Show me all fuel logs where the location is 'LOC456', including the vehicle ID, fuel type, and quantity."}, {"role": "assistant", "content": "SELECT fuel_log_id, vehicle_id, fuel_type, quantity FROM transportation.fuel_logs WHERE location_id = 'LOC456';"}, {"role": "user", "content": "Can you also include the trip ID and filter to only show logs from the last 3 months?"}, {"role": "assistant", "content": "SELECT fuel_log_id, vehicle_id, trip_id, fuel_type, quantity FROM transportation.fuel_logs WHERE location_id = 'LOC456' AND log_timestamp >= CURRENT_DATE - INTERVAL '3 months';"}, {"role": "user", "content": "Now group these results by fuel type and show the total quantity for each type."}, {"role": "assistant", "content": "SELECT fuel_type, SUM(quantity) AS total_quantity FROM transportation.fuel_logs WHERE location_id = 'LOC456' AND log_timestamp >= CURRENT_DATE - INTERVAL '3 months' GROUP BY fuel_type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.fuel_logs ( fuel_log_id.text, vehicle_id.text, trip_id.text, log_timestamp.timestamp, fuel_type.text, quantity.numeric, unit.text, cost_per_unit.numeric, total_cost.numeric, odometer_reading.integer, location_id.text )\n"}
{"conversations": [{"role": "user", "content": "List document names and versions for documents that share the same case_id, showing each pair of versions."}, {"role": "assistant", "content": "SELECT d1.case_id, d1.document_name AS doc_name_v1, d1.version AS version1, d2.document_name AS doc_name_v2, d2.version AS version2 FROM legal_services.documents d1 JOIN legal_services.documents d2 ON d1.case_id = d2.case_id AND d1.version < d2.version;"}, {"role": "user", "content": "Actually, I only want to compare the highest version against the second highest version per case."}, {"role": "assistant", "content": "SELECT d_prev.case_id, d_prev.document_name AS prev_doc, d_prev.version AS prev_version, d_latest.document_name AS latest_doc, d_latest.version AS latest_version FROM legal_services.documents d_latest JOIN legal_services.documents d_prev ON d_latest.case_id = d_prev.case_id AND d_prev.version = d_latest.version - 1 WHERE d_latest.version = (SELECT MAX(version) FROM legal_services.documents d WHERE d.case_id = d_latest.case_id);"}, {"role": "user", "content": "Also include the upload timestamps and restrict to cases with at least three versions."}, {"role": "assistant", "content": "SELECT d_latest.case_id, d_prev.document_name AS prev_doc, d_prev.upload_timestamp AS prev_upload, d_latest.document_name AS latest_doc, d_latest.upload_timestamp AS latest_upload FROM legal_services.documents d_latest JOIN legal_services.documents d_prev ON d_latest.case_id = d_prev.case_id AND d_prev.version = d_latest.version - 1 WHERE d_latest.version = (SELECT MAX(version) FROM legal_services.documents d WHERE d.case_id = d_latest.case_id) AND (SELECT COUNT(*) FROM legal_services.documents d2 WHERE d2.case_id = d_latest.case_id) >= 3;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.documents (\n    document_id character varying(64) NOT NULL,  -- unique identifier for the document\n    case_id character varying(64) NOT NULL, -- FK to cases table\n    document_name character varying(255) NOT NULL, -- name of the document file\n    document_type character varying(100), -- e.g., Pleading, Contract, Evidence, Correspondence\n    storage_path text NOT NULL, -- path or reference to the document storage location\n    uploaded_by_lawyer_id character varying(64), -- FK to lawyers table (who uploaded it)\n    upload_timestamp timestamp NOT NULL, -- time the document was uploaded\n    version integer DEFAULT 1, -- document version number\n    description text, -- brief description or notes about the document\n    PRIMARY KEY (document_id)\n)\n"}
{"conversations": [{"role": "user", "content": "For each developer, can you find the next developer in the same country using a self join, returning developer_ids and names?"}, {"role": "assistant", "content": "SELECT d1.developer_id   AS current_dev,\n       d1.name           AS current_name,\n       d2.developer_id   AS next_dev,\n       d2.name           AS next_name,\n       d2.founded_year - d1.founded_year AS years_diff\nFROM developers d1\nJOIN developers d2\n  ON d1.country = d2.country\n  AND d2.founded_year > d1.founded_year;"}, {"role": "user", "content": "Exclude developers who don't have a next developer, and ensure we only pick the closest next by founded_year."}, {"role": "assistant", "content": "SELECT d1.developer_id   AS current_dev,\n       d1.name           AS current_name,\n       d2.developer_id   AS next_dev,\n       d2.name           AS next_name,\n       d2.founded_year - d1.founded_year AS years_diff\nFROM developers d1\nJOIN LATERAL (\n  SELECT d2.developer_id, d2.name, d2.founded_year\n  FROM developers d2\n  WHERE d2.country = d1.country\n    AND d2.founded_year > d1.founded_year\n  ORDER BY d2.founded_year ASC\n  LIMIT 1\n) d2 ON true;"}, {"role": "user", "content": "Finally, only include pairs where the difference in founded years is at most 5 years."}, {"role": "assistant", "content": "SELECT d1.developer_id   AS current_dev,\n       d1.name           AS current_name,\n       d2.developer_id   AS next_dev,\n       d2.name           AS next_name,\n       d2.founded_year - d1.founded_year AS years_diff\nFROM developers d1\nJOIN LATERAL (\n  SELECT d2.developer_id, d2.name, d2.founded_year\n  FROM developers d2\n  WHERE d2.country = d1.country\n    AND d2.founded_year > d1.founded_year\n  ORDER BY d2.founded_year ASC\n  LIMIT 1\n) d2 ON true\nWHERE (d2.founded_year - d1.founded_year) <= 5\nORDER BY d1.developer_id, years_diff ASC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.developers ( developer_id uuid PRIMARY KEY, name text, country text, founded_year int, website text, created_at timestamptz )\n"}
{"conversations": [{"role": "user", "content": "List tokens that have a 24-hour trading volume greater than $10,000,000 and a negative price change percentage over the last 24 hours. Show the token symbol, chain, total volume, and the 24-hour price change percentage."}, {"role": "assistant", "content": "SELECT token_symbol, chain, total_volume, price_change_percentage_24h FROM token_basic_info WHERE CAST(REPLACE(total_volume, ',', '') AS numeric) > 10000000 AND price_change_percentage_24h < 0"}, {"role": "user", "content": "From those results, filter further to only include tokens with a market cap rank of 100 or better. Order the results by 24-hour trading volume in descending order."}, {"role": "assistant", "content": "SELECT token_symbol, chain, total_volume, price_change_percentage_24h FROM token_basic_info WHERE CAST(REPLACE(total_volume, ',', '') AS numeric) > 10000000 AND price_change_percentage_24h < 0 AND market_cap_rank IS NOT NULL AND market_cap_rank <= 100 ORDER BY CAST(REPLACE(total_volume, ',', '') AS numeric) DESC"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Find all pairs of contracts deployed by the same deployer on the same day, showing the deployer_address, the deployment date, and both contract IDs."}, {"role": "assistant", "content": "SELECT c1.deployer_address,\n       DATE(c1.deployed_at) AS deploy_date,\n       c1.contract_id AS contract_id_1,\n       c2.contract_id AS contract_id_2\nFROM web3.contracts c1\nJOIN web3.contracts c2\n  ON c1.deployer_address = c2.deployer_address\n AND DATE(c1.deployed_at) = DATE(c2.deployed_at)\n AND c1.contract_id < c2.contract_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.contracts ( contract_id.text, address.text, abi.text, bytecode.text, deployer_address.text, deployed_at.timestamp, network_id.text, status.text )\n"}
{"conversations": [{"role": "user", "content": "Show me all business center services (category = 'Business Center') along with their property IDs and descriptions, where the service is available."}, {"role": "assistant", "content": "SELECT service_name, property_id, description FROM hospitality_technology.services WHERE category = 'Business Center' AND is_available = true;"}, {"role": "user", "content": "Now, join this with another query to include the property names from the properties table (assuming properties table has property_id and property_name columns)."}, {"role": "assistant", "content": "SELECT s.service_name, s.property_id, s.description, p.property_name FROM hospitality_technology.services s JOIN hospitality_technology.properties p ON s.property_id = p.property_id WHERE s.category = 'Business Center' AND s.is_available = true;"}, {"role": "user", "content": "The query is missing the price information. Can you include that as well?"}, {"role": "assistant", "content": "SELECT s.service_name, s.property_id, s.description, p.property_name, s.price FROM hospitality_technology.services s JOIN hospitality_technology.properties p ON s.property_id = p.property_id WHERE s.category = 'Business Center' AND s.is_available = true;"}, {"role": "user", "content": "Actually, I need to see only services priced per hour (unit = 'Per Hour'), and order them by property name in alphabetical order."}, {"role": "assistant", "content": "SELECT s.service_name, s.property_id, s.description, p.property_name, s.price FROM hospitality_technology.services s JOIN hospitality_technology.properties p ON s.property_id = p.property_id WHERE s.category = 'Business Center' AND s.is_available = true AND s.unit = 'Per Hour' ORDER BY p.property_name ASC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.services (\n    service_id character varying(64) NOT NULL, -- unique identifier for a chargeable service\n    property_id character varying(64) NOT NULL, -- FK to properties table\n    service_name character varying(150) NOT NULL, -- e.g., Room Service - Burger, Spa - Massage 60min, Laundry - Shirt\n    description text,\n    category character varying(100), -- e.g., Food & Beverage, Wellness, Business Center, Activities\n    price numeric(10, 2) NOT NULL, -- price per unit/instance\n    unit character varying(30), -- e.g., Per Item, Per Hour, Per Day\n    is_available boolean NOT NULL DEFAULT true, -- is the service currently offered?\n    department character varying(100), -- department responsible (e.g., F&B, Spa, Housekeeping)\n    PRIMARY KEY (service_id),\n    FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id)\n)\n"}
{"conversations": [{"role": "user", "content": "How many agents are currently active in each license state?"}, {"role": "assistant", "content": "SELECT license_state, COUNT(*) AS active_agent_count\nFROM insurance.agents\nWHERE status = 'Active'\nGROUP BY license_state;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.claims (\n    claim_id character varying(64) NOT NULL, -- unique identifier for the claim\n    policy_id character varying(64) NOT NULL, -- identifier of the policy under which the claim is made (FK to policies)\n    customer_id character varying(64) NOT NULL, -- identifier of the customer making the claim (FK to customers)\n    incident_date timestamp NOT NULL, -- date and time of the incident leading to the claim\n    reported_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the claim was reported\n    description text NOT NULL, -- detailed description of the incident and claim\n    estimated_loss numeric(15, 2), -- initial estimated cost of the loss\n    status character varying(30) NOT NULL, -- e.g., Filed, Processing, Under Review, Approved, Denied, Settled\n    settlement_amount numeric(15, 2), -- final amount paid out\n    settlement_date date,\n    claim_handler_id character varying(64), -- identifier for the employee handling the claim (FK to employees/adjusters)\n    police_report_number character varying(100),\n    PRIMARY KEY (claim_id)\n)\nCREATE TABLE insurance.agents ( agent_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, agency_name character varying(150), license_number character varying(100) NOT NULL UNIQUE, license_state character varying(50) NOT NULL, contact_email character varying(128) UNIQUE, contact_phone character varying(30), hire_date date, termination_date date, status character varying(20) NOT NULL DEFAULT 'Active', commission_rate numeric(5, 4) NOT NULL DEFAULT 0.05, manager_id character varying(64), PRIMARY KEY (agent_id) )\n"}
{"conversations": [{"role": "user", "content": "List game titles released on the 'PC' platform along with the count of servers currently hosting each game."}, {"role": "assistant", "content": "SELECT T1.title, count(T2.server_id) FROM games AS T1 JOIN servers AS T2 ON T1.game_id = T2.game_id WHERE T1.platform = 'PC' GROUP BY T1.title;"}, {"role": "user", "content": "Now, only show games with more than 3 servers and sort the results by the server count in descending order."}, {"role": "assistant", "content": "SELECT T1.title, count(T2.server_id) AS server_count FROM games AS T1 JOIN servers AS T2 ON T1.game_id = T2.game_id WHERE T1.platform = 'PC' GROUP BY T1.title HAVING count(T2.server_id) > 3 ORDER BY server_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.players (\n    player_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the player\n    username character varying(100) NOT NULL UNIQUE, -- player's chosen display name\n    email character varying(255) NOT NULL UNIQUE, -- player's email address for login/recovery\n    password_hash text NOT NULL, -- securely hashed password\n    registration_date timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the player account was created\n    last_login timestamp with time zone, -- timestamp of the last successful login\n    country_code character(2), -- player's country (ISO 3166-1 alpha-2)\n    status character varying(20) NOT NULL DEFAULT 'active', -- account status (e.g., active, banned, suspended)\n    profile_data jsonb, -- flexible field for avatar url, bio, preferences etc.\n    PRIMARY KEY (player_id)\n)\nCREATE TABLE gaming_technology.games (\n    game_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game\n    title character varying(200) NOT NULL, -- official title of the game\n    developer_id uuid NOT NULL, -- FK linking to the developers table\n    publisher_id uuid, -- FK linking to a potential publishers table (optional)\n    genre character varying(100), -- primary genre (e.g., RPG, FPS, Strategy)\n    release_date date, -- official release date\n    description text, -- short description or synopsis of the game\n    platform character varying(50) NOT NULL, -- primary platform (e.g., PC, PlayStation 5, Xbox Series X, Mobile)\n    engine character varying(100), -- game engine used (e.g., Unreal Engine 5, Unity)\n    website character varying(255), -- official website URL\n    PRIMARY KEY (game_id)\n    -- FOREIGN KEY (developer_id) REFERENCES gaming_technology.developers(developer_id) -- Example FK constraint\n)\nCREATE TABLE gaming_technology.game_sessions (\n    session_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game session\n    player_id uuid NOT NULL, -- FK linking to the players table\n    game_id uuid NOT NULL, -- FK linking to the games table\n    server_id uuid, -- FK linking to the servers table (nullable for single-player)\n    start_time timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the session began\n    end_time timestamp with time zone, -- when the session ended (null if ongoing)\n    duration_seconds integer, -- calculated duration of the session in seconds\n    score integer, -- player's score for the session, if applicable\n    session_data jsonb, -- flexible field for session-specific info (e.g., map played, character used)\n    PRIMARY KEY (session_id)\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id),\n    -- FOREIGN KEY (server_id) REFERENCES gaming_technology.servers(server_id)\n)\nCREATE TABLE gaming_technology.servers (\n    server_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game server instance\n    game_id uuid NOT NULL, -- FK linking to the game this server hosts\n    server_name character varying(150), -- display name for the server\n    region character varying(50) NOT NULL, -- geographical region (e.g., us-east-1, eu-west-2)\n    ip_address character varying(45), -- IP address (IPv4 or IPv6)\n    port integer, -- network port number\n    current_players integer NOT NULL DEFAULT 0, -- number of players currently connected\n    max_players integer NOT NULL, -- maximum player capacity\n    status character varying(30) NOT NULL DEFAULT 'offline', -- server status (e.g., online, offline, maintenance)\n    last_heartbeat timestamp with time zone, -- last time the server reported its status\n    PRIMARY KEY (server_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.achievements (\n    achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an achievement definition\n    game_id uuid NOT NULL, -- FK linking to the game the achievement belongs to\n    name character varying(150) NOT NULL, -- name of the achievement\n    description text NOT NULL, -- how to unlock the achievement\n    icon_url character varying(255), -- URL for the achievement's icon\n    points integer DEFAULT 0, -- points awarded for unlocking (optional)\n    hidden boolean DEFAULT false, -- whether the achievement details are hidden until unlocked\n    PRIMARY KEY (achievement_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.player_achievements (\n    player_achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for this unlock instance\n    player_id uuid NOT NULL, -- FK linking to the player who unlocked it\n    achievement_id uuid NOT NULL, -- FK linking to the achievement definition\n    unlocked_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the achievement was unlocked\n    PRIMARY KEY (player_achievement_id),\n    UNIQUE (player_id, achievement_id) -- Ensure a player can only unlock an achievement once\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (achievement_id) REFERENCES gaming_technology.achievements(achievement_id)\n)\nCREATE TABLE gaming_technology.in_game_items (\n    item_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the item definition\n    game_id uuid NOT NULL, -- FK linking to the game this item belongs to\n    item_name character varying(150) NOT NULL, -- name of the item\n    item_type character varying(50) NOT NULL, -- type (e.g., Cosmetic, Consumable, Weapon, Armor)\n    description text, -- description of the item\n    rarity character varying(30), -- item rarity (e.g., Common, Rare, Epic, Legendary)\n    cost_currency character varying(10), -- currency code if purchasable (e.g., USD, EUR, GOLD)\n    cost_amount numeric(12, 2), -- price if purchasable\n    attributes jsonb, -- flexible field for item stats or properties\n    PRIMARY KEY (item_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.player_inventory (\n    inventory_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an inventory entry\n    player_id uuid NOT NULL, -- FK linking to the player owning the item\n    item_id uuid NOT NULL, -- FK linking to the item definition\n    quantity integer NOT NULL DEFAULT 1, -- number of items held (for stackable items)\n    acquired_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the item was acquired\n    instance_data jsonb, -- data specific to this instance (e.g., weapon mods, durability)\n    PRIMARY KEY (inventory_id),\n    -- Optional unique constraint if items are non-stackable or unique instances\n    -- UNIQUE (player_id, item_id) -- Use if quantity is always 1\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (item_id) REFERENCES gaming_technology.in_game_items(item_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Provide a list of all vehicles and the total quantity of fuel refueled for each vehicle."}, {"role": "assistant", "content": "SELECT T1.license_plate, sum(T2.quantity) FROM transportation.vehicles AS T1 JOIN transportation.fuel_logs AS T2 ON T1.vehicle_id = T2.vehicle_id GROUP BY T1.license_plate"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE transportation.passengers ( passenger_id text PRIMARY KEY, first_name text, last_name text, email text, phone_number text, date_of_birth date, loyalty_program_id text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "What is the fuel efficiency of the train car with car_id 'TC456'?"}, {"role": "assistant", "content": "I'm sorry, but I don't have access to information about the fuel efficiency of specific train cars. The data available in the train_cars table only includes details such as car_id, train_id, car_number, car_type, class, capacity, and features. If you have another question or need assistance with something else, I'm happy to help."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.train_cars ( car_id.text, train_id.text, car_number.text, car_type.text, class.text, capacity.integer, features.text )\n"}
{"conversations": [{"role": "user", "content": "For each ERC1155 NFT contract on Ethereum, show the `contract_address`, `token_id`, total amount held across all wallets, and number of unique holders."}, {"role": "assistant", "content": "SELECT nh.contract_address,\n       nh.token_id,\n       SUM(CAST(nh.amount AS bigint)) AS total_amount,\n       COUNT(DISTINCT nh.wallet_address) AS holder_count\nFROM nft_holders nh\nJOIN nft_metadata nm\n  ON nh.contract_address = nm.contract_address\n  AND nh.token_id = nm.token_id\nWHERE nm.blockchain = 'Ethereum'\n  AND nm.erc_type = 'ERC1155'\nGROUP BY nh.contract_address, nh.token_id;"}, {"role": "user", "content": "Only include NFTs where the `total_amount` is greater than 1000."}, {"role": "assistant", "content": "SELECT nh.contract_address,\n       nh.token_id,\n       SUM(CAST(nh.amount AS bigint)) AS total_amount,\n       COUNT(DISTINCT nh.wallet_address) AS holder_count\nFROM nft_holders nh\nJOIN nft_metadata nm\n  ON nh.contract_address = nm.contract_address\n  AND nh.token_id = nm.token_id\nWHERE nm.blockchain = 'Ethereum'\n  AND nm.erc_type = 'ERC1155'\nGROUP BY nh.contract_address, nh.token_id\nHAVING SUM(CAST(nh.amount AS bigint)) > 1000;"}, {"role": "user", "content": "Add the NFT `name` from `nft_metadata` in the result."}, {"role": "assistant", "content": "SELECT nh.contract_address,\n       nh.token_id,\n       nm.name,\n       SUM(CAST(nh.amount AS bigint)) AS total_amount,\n       COUNT(DISTINCT nh.wallet_address) AS holder_count\nFROM nft_holders nh\nJOIN nft_metadata nm\n  ON nh.contract_address = nm.contract_address\n  AND nh.token_id = nm.token_id\nWHERE nm.blockchain = 'Ethereum'\n  AND nm.erc_type = 'ERC1155'\nGROUP BY nh.contract_address, nh.token_id, nm.name\nHAVING SUM(CAST(nh.amount AS bigint)) > 1000;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE erc1155_approval_for_all (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction\n    transaction_index integer NOT NULL, -- Index of the transaction within the block\n    transaction_hash varchar(66) NOT NULL, -- Transaction hash\n    log_index integer NOT NULL, -- Log index\n    contract_address varchar(42) NOT NULL  -- Event contract address\n)\nCREATE TABLE nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE sui_coins ( object_id varchar NOT NULL, status varchar NOT NULL, coin_type varchar NOT NULL, balance varchar NOT NULL, owner varchar NOT NULL )\nCREATE TABLE sui_coins_metadata (\n    object_id varchar NOT NULL, -- object id of the coin metadata object\n    coin_type varchar NOT NULL, -- coin type, eg. 0x...66::reap_token::REAP_TOKEN\n    status varchar NOT NULL, -- coin status, eg. exists, deleted\n    decimals bigint NOT NULL, -- decimals of the coin\n    description varchar NOT NULL, -- description of the coin\n    icon_url varchar NOT NULL, -- icon url of the coin\n    symbol varchar NOT NULL, -- symbol of the coin\n    name varchar NOT NULL  -- name of the coin\n)\nCREATE 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 )\nCREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint NOT NULL, block_timestamp timestamp(6) NOT NULL, transaction_index integer NOT NULL, transaction_hash varchar NOT NULL, log_index integer NOT NULL, contract_address varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_balances ( block_number.bigint, block_timestamp.timestamp, tick.text, wallet_address.text, total_supply.decimal, amount.decimal )\nCREATE TABLE token_info (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    tick varchar NOT NULL, -- Token tick\n    max_supply decimal(38,0) NOT NULL, -- Max supply\n    lim decimal(38,0) NOT NULL, -- Limit of each mint\n    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint\n    dec integer NOT NULL, -- Decimal for minimum divie\n    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)\n)\nCREATE TABLE mud_holesky_redstone (\n    address varchar NOT NULL, -- address fields for the functionType  in contract\n    table_id varchar NOT NULL, -- table_id fields for the functionType  in contract\n    key_bytes varchar NOT NULL, -- key_bytes fields for the functionType  in contract\n    key0 varchar NOT NULL, -- key0 fields for the functionType  in contract\n    key1 varchar NOT NULL, -- key1 fields for the functionType  in contract\n    static_data varchar NOT NULL, -- static_data fields for the functionType  in contract\n    encoded_lengths varchar NOT NULL, -- encoded_lengths fields for the functionType  in contract\n    dynamic_data varchar NOT NULL, -- dynamic_data fields for the functionType  in contract\n    is_deleted boolean NOT NULL, -- is_deleted fields for the functionType  in contract\n    block_number bigint NOT NULL, -- Block number uniquely identifying the block\n    log_index bigint NOT NULL  -- Index of the log within the transaction\n)\nCREATE 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 )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, log_index integer, type text, tick text, id text, amt decimal, from_address text, to_address text )\nCREATE TABLE token_balances_avalanche ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )\n"}
{"conversations": [{"role": "user", "content": "Show me document_id, application_id, and verification_status for all documents submitted by citizen 'cit123'."}, {"role": "assistant", "content": "SELECT document_id,\n       application_id,\n       verification_status\nFROM documents\nWHERE citizen_id = 'cit123';"}, {"role": "user", "content": "I got an error: relation 'documents' does not exist."}, {"role": "assistant", "content": "SELECT document_id,\n       application_id,\n       verification_status\nFROM government_services.documents\nWHERE citizen_id = 'cit123';"}, {"role": "user", "content": "Now, only include documents where verification_status = 'Pending'."}, {"role": "assistant", "content": "SELECT document_id,\n       application_id,\n       verification_status\nFROM government_services.documents\nWHERE citizen_id = 'cit123'\n  AND verification_status = 'Pending';"}, {"role": "user", "content": "Also, limit the results to files uploaded in 2024."}, {"role": "assistant", "content": "SELECT document_id,\n       application_id,\n       verification_status\nFROM government_services.documents\nWHERE citizen_id = 'cit123'\n  AND verification_status = 'Pending'\n  AND upload_timestamp >= '2024-01-01'\n  AND upload_timestamp < '2025-01-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE government_services.employees ( employee_id text, agency_id text, first_name text, last_name text, job_title text, department text, work_email text, work_phone text, hire_date date, termination_date date, access_level text, manager_employee_id text )\nCREATE TABLE government_services.service_locations ( location_id text, agency_id text, location_name text, address text, city text, state text, postal_code text, latitude numeric, longitude numeric, operating_hours text, contact_phone text, is_accessible boolean )\nCREATE TABLE government_services.appointments ( appointment_id text, citizen_id text, employee_id text, location_id text, service_id text, scheduled_start_time timestamp, scheduled_end_time timestamp, purpose text, status text, booking_method text, created_at timestamp, notes text )\n"}
{"conversations": [{"role": "user", "content": "List all post IDs and their corresponding hashtag names for posts that include media."}, {"role": "assistant", "content": "SELECT ph.post_id, h.tag_name\nFROM social_media.post_hashtags ph\nJOIN social_media.hashtags h ON ph.hashtag_id = h.hashtag_id\nJOIN social_media.posts p ON ph.post_id = p.post_id\nWHERE p.media_url IS NOT NULL AND p.media_url != '';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE social_media.follows (\n    follow_id character varying(64) NOT NULL, -- unique identifier for the follow relationship\n    follower_user_id character varying(64) NOT NULL, -- identifier of the user who is following (FK to users.user_id)\n    following_user_id character varying(64) NOT NULL, -- identifier of the user being followed (FK to users.user_id)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of when the follow started\n    PRIMARY KEY (follow_id),\n    CONSTRAINT unique_follow UNIQUE (follower_user_id, following_user_id) -- prevent duplicate follows\n)\nCREATE 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) )\nCREATE TABLE social_media.post_hashtags (\n    post_hashtag_id character varying(64) NOT NULL, -- unique identifier for the post-hashtag link\n    post_id character varying(64) NOT NULL, -- identifier of the post (FK to posts.post_id)\n    hashtag_id character varying(64) NOT NULL, -- identifier of the hashtag (FK to hashtags.hashtag_id)\n    PRIMARY KEY (post_hashtag_id),\n    CONSTRAINT unique_post_hashtag UNIQUE (post_id, hashtag_id) -- prevent duplicate tags on a post\n)\nCREATE TABLE social_media.messages (\n    message_id character varying(64) NOT NULL, -- unique identifier for the message\n    conversation_id character varying(64) NOT NULL, -- identifier for the conversation thread (FK to conversations.conversation_id)\n    sender_user_id character varying(64) NOT NULL, -- identifier of the sender (FK to users.user_id)\n    content text, -- textual content of the message\n    media_url text, -- URL to attached media (image/video)\n    media_type character varying(20), -- type of media ('image', 'video', null)\n    sent_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when message was sent\n    read_at timestamp, -- timestamp when message was read by recipient(s)\n    PRIMARY KEY (message_id)\n)\nCREATE TABLE social_media.conversations ( conversation_id text PRIMARY KEY, created_at timestamp, last_message_at timestamp, is_group_chat bool, group_name text )\nCREATE TABLE social_media.conversation_participants (\n    participant_id character varying(64) NOT NULL, -- unique identifier for the participant entry\n    conversation_id character varying(64) NOT NULL, -- identifier of the conversation (FK to conversations.conversation_id)\n    user_id character varying(64) NOT NULL, -- identifier of the user in the conversation (FK to users.user_id)\n    joined_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when user joined the conversation\n    last_read_at timestamp, -- timestamp indicating up to when the user has read messages\n    PRIMARY KEY (participant_id),\n    CONSTRAINT unique_user_conversation UNIQUE (conversation_id, user_id) -- prevent user being added multiple times\n)\nCREATE TABLE social_media.notifications (\n    notification_id character varying(64) NOT NULL, -- unique identifier for the notification\n    recipient_user_id character varying(64) NOT NULL, -- user receiving the notification (FK to users.user_id)\n    sender_user_id character varying(64), -- user triggering the notification (FK to users.user_id, can be null for system notifications)\n    notification_type character varying(30) NOT NULL, -- type of notification ('like', 'comment', 'follow', 'mention', 'message')\n    target_entity_id character varying(64), -- ID of the related entity (post_id, comment_id, user_id, conversation_id)\n    target_entity_type character varying(20), -- type of the related entity ('post', 'comment', 'user', 'conversation')\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp notification was created\n    read_at timestamp, -- timestamp notification was marked as read\n    PRIMARY KEY (notification_id)\n)\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "Show me all ERC20 token transfers where the amount is over 5000, including the sender and receiver addresses."}, {"role": "assistant", "content": "SELECT from_address, to_address, amt, tick, tx_hash FROM token_activities WHERE type = 'transfer' AND CAST(amt AS DECIMAL) > 5000;"}, {"role": "user", "content": "Add the token symbol and decimals for each transfer by joining to the latest token price table."}, {"role": "assistant", "content": "SELECT ta.from_address, ta.to_address, ta.amt, ta.tick, ta.tx_hash, tpl.symbol, tpl.decimals FROM token_activities ta JOIN token_prices_latest tpl ON ta.tick = tpl.symbol WHERE ta.type = 'transfer' AND CAST(ta.amt AS DECIMAL) > 5000;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE erc20_balances ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk varchar )\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk integer )\nCREATE TABLE nft_holder_historical ( block_number bigint, contract_address varchar, wallet_address varchar, token_id varchar, contract_type varchar, amount varchar, pk integer )\nCREATE TABLE sui_coins ( object_id varchar, status varchar, coin_type varchar, balance varchar, owner varchar )\nCREATE TABLE sui_coins_metadata ( object_id varchar, coin_type varchar, status varchar, decimals bigint, description varchar, icon_url varchar, symbol varchar, name varchar )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE token_prices_latest ( blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash varchar, log_index integer, contract_address varchar, pk integer )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List the appointment ID, start time, and the case number for all appointments that are linked to a case."}, {"role": "assistant", "content": "SELECT T1.appointment_id, T1.start_time, T2.case_number FROM legal_services.appointments AS T1 JOIN legal_services.cases AS T2 ON T1.case_id = T2.case_id"}, {"role": "user", "content": "Refine this to only show appointments with status 'completed' associated with cases with status 'Closed'."}, {"role": "assistant", "content": "SELECT T1.appointment_id, T1.start_time, T2.case_number FROM legal_services.appointments AS T1 JOIN legal_services.cases AS T2 ON T1.case_id = T2.case_id WHERE T1.status = 'completed' AND T2.status = 'Closed'"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.cases ( case_id text, case_number text, case_name text, client_id text, lead_lawyer_id text, case_type text, status text, date_opened timestamp, date_closed timestamp, description text, court_jurisdiction text )\nCREATE TABLE legal_services.appointments ( appointment_id text, client_id text, lawyer_id text, case_id text, start_time timestamp, end_time timestamp, location text, subject text, notes text, status text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show pairs of time entries for the same lawyer on the same date with different billing rates, including both entry IDs, the lawyer ID, the work date, and both billing rates."}, {"role": "assistant", "content": "SELECT a.entry_id AS entry1_id, b.entry_id AS entry2_id, a.lawyer_id, a.date_worked, a.billing_rate AS rate1, b.billing_rate AS rate2\nFROM legal_services.time_entries a\nJOIN legal_services.time_entries b\n  ON a.lawyer_id = b.lawyer_id\n  AND a.date_worked = b.date_worked\n  AND a.entry_id < b.entry_id\n  AND a.billing_rate <> b.billing_rate;"}, {"role": "user", "content": "Actually, I only want to include entries where both are billable."}, {"role": "assistant", "content": "SELECT a.entry_id AS entry1_id, b.entry_id AS entry2_id, a.lawyer_id, a.date_worked, a.billing_rate AS rate1, b.billing_rate AS rate2\nFROM legal_services.time_entries a\nJOIN legal_services.time_entries b\n  ON a.lawyer_id = b.lawyer_id\n  AND a.date_worked = b.date_worked\n  AND a.entry_id < b.entry_id\n  AND a.billing_rate <> b.billing_rate\nWHERE a.is_billable = true\n  AND b.is_billable = true;"}, {"role": "user", "content": "Also, sort the results by lawyer_id, then by date_worked, and then by the absolute difference in billing rates descending."}, {"role": "assistant", "content": "SELECT a.entry_id AS entry1_id, b.entry_id AS entry2_id, a.lawyer_id, a.date_worked, a.billing_rate AS rate1, b.billing_rate AS rate2\nFROM legal_services.time_entries a\nJOIN legal_services.time_entries b\n  ON a.lawyer_id = b.lawyer_id\n  AND a.date_worked = b.date_worked\n  AND a.entry_id < b.entry_id\n  AND a.billing_rate <> b.billing_rate\nWHERE a.is_billable = true\n  AND b.is_billable = true\nORDER BY a.lawyer_id, a.date_worked, ABS(a.billing_rate - b.billing_rate) DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.time_entries ( entry_id.text, case_id.text, lawyer_id.text, date_worked.date, hours_spent.numeric, billing_rate.numeric, description.text, is_billable.boolean, is_billed.boolean, invoice_id.text, created_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "List every guest along with every room type available in the system."}, {"role": "assistant", "content": "SELECT g.guest_id, g.first_name, g.last_name, rt.room_type_id, rt.type_name\nFROM hospitality_technology.guests g\nCROSS JOIN hospitality_technology.room_types rt;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.room_types (\n    room_type_id character varying(64) NOT NULL, -- unique identifier for the room type\n    property_id character varying(64) NOT NULL, -- FK to properties table (type might be property-specific)\n    type_name character varying(100) NOT NULL, -- e.g., Standard King, Deluxe Queen, Executive Suite\n    description text, -- description of the room type\n    base_rate numeric(10, 2) NOT NULL, -- standard price per night\n    max_occupancy integer NOT NULL, -- maximum number of guests\n    bed_type character varying(50), -- e.g., King, Queen, 2 Doubles, Twin\n    area_sqft numeric(8,2), -- size of the room in square feet\n    amenities text, -- comma-separated list or JSON of amenities\n    PRIMARY KEY (room_type_id),\n    FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id)\n)\nCREATE TABLE hospitality_technology.guests ( guest_id text PRIMARY KEY, first_name text, last_name text, email text, phone_number text, date_of_birth date, address_line1 text, city text, state_province text, postal_code text, country_code text, preferences text, loyalty_member_id text, communication_consent boolean, created_at timestamp, updated_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show each wallet address that has received token transfers of more than one type of token, along with the count of token types received."}, {"role": "assistant", "content": "SELECT tt.to_address, COUNT(DISTINCT tt.token_id) AS token_type_count\nFROM web3.token_transfers tt\nGROUP BY tt.to_address\nHAVING COUNT(DISTINCT tt.token_id) > 1;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.contracts ( contract_id text PRIMARY KEY, address text, abi text, bytecode text, deployer_address text, deployed_at timestamp, network_id text, status text )\nCREATE TABLE web3.events ( event_id character varying(64) NOT NULL, contract_id character varying(64) NOT NULL, event_name character varying(128) NOT NULL, data text NOT NULL, emitted_at timestamp NOT NULL, transaction_id character varying(64) NOT NULL, log_index integer NOT NULL, PRIMARY KEY (event_id) )\nCREATE TABLE web3.tokens (\n    token_id character varying(64) NOT NULL,  -- unique identifier for the token\n    contract_address character varying(128) NOT NULL, -- address of the token contract\n    token_name character varying(128) NOT NULL, -- name of the token\n    token_symbol character varying(32) NOT NULL, -- symbol of the token\n    decimals integer NOT NULL, -- number of decimals for the token\n    total_supply numeric(38,14) NOT NULL, -- total supply of the token\n    PRIMARY KEY (token_id)\n)\nCREATE TABLE web3.token_transfers ( transfer_id character varying(64) NOT NULL, token_id character varying(64) NOT NULL, from_address character varying(128) NOT NULL, to_address character varying(128) NOT NULL, value numeric(38,14) NOT NULL, transaction_id character varying(64) NOT NULL, log_index integer NOT NULL, PRIMARY KEY (transfer_id) )\nCREATE TABLE web3.wallets (\n    wallet_id character varying(64) NOT NULL,  -- unique identifier for the wallet\n    user_id character varying(64) NOT NULL, -- identifier of the user owning the wallet\n    address character varying(128) NOT NULL, -- address of the wallet\n    private_key text NOT NULL, -- private key of the wallet\n    created_at timestamp NOT NULL, -- time when the wallet was created\n    PRIMARY KEY (wallet_id)\n)\nCREATE TABLE web3.users (\n    user_id character varying(64) NOT NULL,  -- unique identifier for the user\n    username character varying(128) NOT NULL, -- username of the user\n    email character varying(128) NOT NULL, -- email address of the user\n    password_hash text NOT NULL, -- hashed password of the user\n    created_at timestamp NOT NULL, -- time when the user account was created\n    PRIMARY KEY (user_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me a list of comments and the names of hashtags associated with the posts those comments are on."}, {"role": "assistant", "content": "SELECT T1.comment_id, T3.tag_name FROM comments AS T1 JOIN post_hashtags AS T2 ON T1.post_id = T2.post_id JOIN hashtags AS T3 ON T2.hashtag_id = T3.hashtag_id;"}, {"role": "user", "content": "Can you also include the content of the comment and filter the results to only show comments on posts tagged with 'photography'?"}, {"role": "assistant", "content": "SELECT T1.comment_id, T1.content, T3.tag_name FROM comments AS T1 JOIN post_hashtags AS T2 ON T1.post_id = T2.post_id JOIN hashtags AS T3 ON T2.hashtag_id = T3.hashtag_id WHERE T3.tag_name = 'photography';"}, {"role": "user", "content": "Please only list comments that are top-level, meaning they are not replies to other comments."}, {"role": "assistant", "content": "SELECT T1.comment_id, T1.content, T3.tag_name FROM comments AS T1 JOIN post_hashtags AS T2 ON T1.post_id = T2.post_id JOIN hashtags AS T3 ON T2.hashtag_id = T3.hashtag_id WHERE T3.tag_name = 'photography' AND T1.parent_comment_id IS NULL;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE social_media.comments ( comment_id.text, post_id.text, user_id.text, parent_comment_id.text, content.text, created_at.timestamp, updated_at.timestamp )\nCREATE TABLE social_media.follows ( follow_id.text, follower_user_id.text, following_user_id.text, created_at.timestamp )\nCREATE TABLE social_media.hashtags ( hashtag_id.text, tag_name.text, created_at.timestamp )\nCREATE TABLE social_media.post_hashtags ( post_hashtag_id.text, post_id.text, hashtag_id.text )\nCREATE TABLE social_media.conversations ( conversation_id.text, created_at.timestamp, last_message_at.timestamp, is_group_chat.boolean, group_name.text )\n"}
{"conversations": [{"role": "user", "content": "For each game, count the total number of achievements unlocked across all players. Show game title and count."}, {"role": "assistant", "content": "SELECT g.title, COUNT(pa.player_achievement_id) AS total_unlocked_achievements FROM gaming_technology.games AS g JOIN gaming_technology.achievements AS a ON g.game_id = a.game_id JOIN gaming_technology.player_achievements AS pa ON a.achievement_id = pa.achievement_id GROUP BY g.title;"}, {"role": "user", "content": "Only include games that have more than 100 achievements unlocked."}, {"role": "assistant", "content": "SELECT g.title, COUNT(pa.player_achievement_id) AS total_unlocked_achievements FROM gaming_technology.games AS g JOIN gaming_technology.achievements AS a ON g.game_id = a.game_id JOIN gaming_technology.player_achievements AS pa ON a.achievement_id = pa.achievement_id GROUP BY g.title HAVING COUNT(pa.player_achievement_id) > 100;"}, {"role": "user", "content": "For these games, also show the number of servers hosting that game."}, {"role": "assistant", "content": "SELECT g.title, COUNT(pa.player_achievement_id) AS total_unlocked_achievements, COUNT(s.server_id) AS server_count FROM gaming_technology.games AS g JOIN gaming_technology.achievements AS a ON g.game_id = a.game_id JOIN gaming_technology.player_achievements AS pa ON a.achievement_id = pa.achievement_id LEFT JOIN gaming_technology.servers AS s ON g.game_id = s.game_id GROUP BY g.title HAVING COUNT(pa.player_achievement_id) > 100;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.players ( player_id uuid NOT NULL DEFAULT gen_random_uuid(), username character varying(100) NOT NULL UNIQUE, email character varying(255) NOT NULL UNIQUE, password_hash text NOT NULL, registration_date timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, last_login timestamp with time zone, country_code character(2), status character varying(20) NOT NULL DEFAULT 'active', profile_data jsonb, PRIMARY KEY (player_id) )\nCREATE TABLE gaming_technology.games ( game_id uuid NOT NULL DEFAULT gen_random_uuid(), title character varying(200) NOT NULL, developer_id uuid NOT NULL, publisher_id uuid, genre character varying(100), release_date date, description text, platform character varying(50) NOT NULL, engine character varying(100), website character varying(255), PRIMARY KEY (game_id) )\nCREATE TABLE gaming_technology.developers ( developer_id uuid NOT NULL DEFAULT gen_random_uuid(), name character varying(150) NOT NULL UNIQUE, country character varying(100), founded_year integer, website character varying(255), created_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (developer_id) )\nCREATE TABLE gaming_technology.servers ( server_id uuid NOT NULL DEFAULT gen_random_uuid(), game_id uuid NOT NULL, server_name character varying(150), region character varying(50) NOT NULL, ip_address character varying(45), port integer, current_players integer NOT NULL DEFAULT 0, max_players integer NOT NULL, status character varying(30) NOT NULL DEFAULT 'offline', last_heartbeat timestamp with time zone, PRIMARY KEY (server_id) )\nCREATE TABLE gaming_technology.achievements ( achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), game_id uuid NOT NULL, name character varying(150) NOT NULL, description text NOT NULL, icon_url character varying(255), points integer DEFAULT 0, hidden boolean DEFAULT false, PRIMARY KEY (achievement_id) )\nCREATE 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) )\nCREATE 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) )\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "List all claim IDs that have both an 'Accident Report' and a 'Damage Assessment' document, and show the earliest upload timestamp for each type."}, {"role": "assistant", "content": "SELECT a.claim_id,\n       MIN(a.uploaded_at) AS accident_report_date,\n       MIN(d.uploaded_at) AS damage_assessment_date\nFROM insurance.claim_documents AS a\nJOIN insurance.claim_documents AS d\n  ON a.claim_id = d.claim_id\nWHERE a.document_type = 'Accident Report'\n  AND d.document_type = 'Damage Assessment'\nGROUP BY a.claim_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.claim_documents ( document_id.text, claim_id.text, document_type.text, file_name.text, file_path.text, file_size_bytes.integer, mime_type.text, uploaded_by.text, uploaded_at.timestamp, description.text )\n"}
{"conversations": [{"role": "user", "content": "What are the fuel consumption rates per hour for the Boeing 747-8 model?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information on the fuel consumption rates for the Boeing 747-8 model as this data is not included in the aircraft_models table. The table contains details such as model name, manufacturer, passenger capacity, and other specifications, but fuel consumption data is not available. If you have another question or need assistance with something else related to the table, I'm happy to help."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE manufacturing.aircraft_models ( model_id.text, model_name.text, manufacturer.text, passenger_capacity.integer, max_range_km.integer, engine_type.text, wingspan_m.numeric, status.text, first_flight_date.date )\n"}
{"conversations": [{"role": "user", "content": "For product types that have both active and inactive products, list each pair of product IDs along with the shared product_type and their is_active statuses."}, {"role": "assistant", "content": "SELECT p1.product_id AS active_id, p2.product_id AS inactive_id, p1.product_type, p1.is_active AS active_status, p2.is_active AS inactive_status FROM insurance.insurance_products p1 JOIN insurance.insurance_products p2 ON p1.product_type = p2.product_type AND p1.is_active = TRUE AND p2.is_active = FALSE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.insurance_products ( product_id.text, 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me all cryptocurrency assets that have been traded more than 50 times but have never been traded in quantities greater than 100, along with their average trade price."}, {"role": "assistant", "content": "SELECT a.asset_id, a.name, a.symbol, COUNT(t.trade_id) AS trade_count, AVG(t.price) AS avg_price FROM trading_platform.assets a JOIN trading_platform.trades t ON a.asset_id = t.asset_id WHERE a.type = 'cryptocurrency' GROUP BY a.asset_id, a.name, a.symbol HAVING COUNT(t.trade_id) > 50 AND MAX(t.quantity) <= 100;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.users ( user_id character varying(64) NOT NULL, username character varying(128) NOT NULL, email character varying(128) NOT NULL, password_hash text NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (user_id) )\nCREATE TABLE trading_platform.wallets ( wallet_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, address character varying(128) NOT NULL, private_key text NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (wallet_id) )\nCREATE TABLE trading_platform.orders ( order_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, wallet_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, order_type character varying(32) NOT NULL, quantity numeric(38,14) NOT NULL, price numeric(38,14) NOT NULL, status character varying(32) NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (order_id) )\nCREATE TABLE trading_platform.trades ( trade_id character varying(64) NOT NULL, order_id character varying(64) NOT NULL, buyer_id character varying(64) NOT NULL, seller_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, quantity numeric(38,14) NOT NULL, price numeric(38,14) NOT NULL, traded_at timestamp NOT NULL, PRIMARY KEY (trade_id) )\nCREATE TABLE trading_platform.assets ( asset_id character varying(64) NOT NULL, name character varying(128) NOT NULL, symbol character varying(32) NOT NULL, type character varying(32) NOT NULL, PRIMARY KEY (asset_id) )\nCREATE TABLE trading_platform.utxos ( utxo_id character varying(64) NOT NULL, transaction_id character varying(64) NOT NULL, output_index integer NOT NULL, address character varying(128) NOT NULL, amount numeric(38,14) NOT NULL, spent boolean NOT NULL, PRIMARY KEY (utxo_id) )\nCREATE TABLE trading_platform.dapps ( dapp_id character varying(64) NOT NULL, name character varying(128) NOT NULL, description text NOT NULL, url character varying(256) NOT NULL, PRIMARY KEY (dapp_id) )\nCREATE TABLE trading_platform.peers ( peer_id character varying(64) NOT NULL, ip_address character varying(15) NOT NULL, port integer NOT NULL, last_seen timestamp NOT NULL, PRIMARY KEY (peer_id) )\nCREATE TABLE trading_platform.metadata ( metadata_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, key character varying(128) NOT NULL, value text NOT NULL, PRIMARY KEY (metadata_id) )\nCREATE TABLE trading_platform.kyc_audit ( kyc_audit_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, status character varying(32) NOT NULL, reviewed_at timestamp NOT NULL, PRIMARY KEY (kyc_audit_id) )\nCREATE TABLE trading_platform.notifications ( notification_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, message text NOT NULL, sent_at timestamp NOT NULL, read_at timestamp, PRIMARY KEY (notification_id) )\n"}
{"conversations": [{"role": "user", "content": "List all pairs of hashtags that were created on the same date. Show both tag names and the creation date."}, {"role": "assistant", "content": "SELECT a.tag_name AS tag1, b.tag_name AS tag2, a.created_at::date AS created_date\nFROM social_media.hashtags a\nJOIN social_media.hashtags b\n  ON a.created_at::date = b.created_at::date\n  AND a.hashtag_id < b.hashtag_id;"}, {"role": "user", "content": "Actually, only include pairs where both tag names start with the letter 'S'."}, {"role": "assistant", "content": "SELECT a.tag_name AS tag1, b.tag_name AS tag2, a.created_at::date AS created_date\nFROM social_media.hashtags a\nJOIN social_media.hashtags b\n  ON a.created_at::date = b.created_at::date\n  AND a.hashtag_id < b.hashtag_id\nWHERE a.tag_name LIKE 'S%'\n  AND b.tag_name LIKE 'S%';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "Get the number of agents grouped by status. Return status and agent_count."}, {"role": "assistant", "content": "SELECT status,\n       COUNT(*) AS agent_count\n  FROM insurance.agents\n GROUP BY status;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all invoices where amount_paid is less than total_amount."}, {"role": "assistant", "content": "SELECT *\nFROM legal_services.invoices\nWHERE amount_paid < total_amount;"}, {"role": "user", "content": "Only include those with due_date before today."}, {"role": "assistant", "content": "SELECT *\nFROM legal_services.invoices\nWHERE amount_paid < total_amount\n  AND due_date < CURRENT_DATE;"}, {"role": "user", "content": "Now also compute how many days each invoice is overdue as difference between CURRENT_DATE and due_date, and only show those overdue by more than 30 days."}, {"role": "assistant", "content": "SELECT invoice_id,\n       invoice_number,\n       client_id,\n       total_amount,\n       amount_paid,\n       due_date,\n       CURRENT_DATE - due_date AS days_overdue\nFROM legal_services.invoices\nWHERE amount_paid < total_amount\n  AND due_date < CURRENT_DATE\n  AND CURRENT_DATE - due_date > 30;"}, {"role": "user", "content": "Finally, order the result by days_overdue descending."}, {"role": "assistant", "content": "SELECT invoice_id,\n       invoice_number,\n       client_id,\n       total_amount,\n       amount_paid,\n       due_date,\n       CURRENT_DATE - due_date AS days_overdue\nFROM legal_services.invoices\nWHERE amount_paid < total_amount\n  AND due_date < CURRENT_DATE\n  AND CURRENT_DATE - due_date > 30\nORDER BY days_overdue DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "How many employees work in each department? List the department name and the count."}, {"role": "assistant", "content": "SELECT department, COUNT(*) FROM government_services.employees GROUP BY department"}, {"role": "user", "content": "Only show departments with more than 5 employees."}, {"role": "assistant", "content": "SELECT department, COUNT(*) FROM government_services.employees GROUP BY department HAVING COUNT(*) > 5"}, {"role": "user", "content": "For these departments, also list the job titles present."}, {"role": "assistant", "content": "SELECT department, COUNT(*), STRING_AGG(DISTINCT job_title, ', ') FROM government_services.employees GROUP BY department HAVING COUNT(*) > 5"}, {"role": "user", "content": "Add the total number of employees hired in 2023 for each of these departments."}, {"role": "assistant", "content": "SELECT department, COUNT(*), STRING_AGG(DISTINCT job_title, ', '), SUM(CASE WHEN EXTRACT(YEAR FROM hire_date) = 2023 THEN 1 ELSE 0 END) AS employees_hired_in_2023 FROM government_services.employees GROUP BY department HAVING COUNT(*) > 5"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE government_services.services (\n    service_id character varying(64) NOT NULL, -- unique identifier for the service\n    agency_id character varying(64) NOT NULL, -- FK to agencies table\n    service_name character varying(255) NOT NULL, -- name of the service (e.g., Driver's License Renewal)\n    description text,\n    category character varying(100), -- e.g., Licensing, Benefits, Taxation, Permits\n    eligibility_criteria text, -- description of who is eligible\n    standard_fee numeric(10, 2) DEFAULT 0.00, -- typical fee for the service\n    average_processing_time_days integer, -- estimated processing time\n    is_active boolean DEFAULT true, -- whether the service is currently offered\n    online_application_url character varying(255),\n    PRIMARY KEY (service_id)\n)\nCREATE TABLE government_services.employees ( employee_id text, agency_id text, first_name text, last_name text, job_title text, department text, work_email text, work_phone text, hire_date date, termination_date date, access_level text, manager_employee_id text )\nCREATE 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) )\nCREATE TABLE government_services.appointments ( appointment_id.text, citizen_id.text, employee_id.text, location_id.text, service_id.text, scheduled_start_time.timestamp, scheduled_end_time.timestamp, purpose.text, status.text, booking_method.text, created_at.timestamp, notes.text )\n"}
{"conversations": [{"role": "user", "content": "For each city and state, show the number of service locations available along with their accessibility status."}, {"role": "assistant", "content": "SELECT city, state, is_accessible, COUNT(*) AS location_count FROM government_services.service_locations GROUP BY city, state, is_accessible;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.service_locations ( location_id text, agency_id text, location_name text, address text, city text, state text, postal_code text, latitude numeric, longitude numeric, operating_hours text, contact_phone text, is_accessible boolean )\n"}
{"conversations": [{"role": "user", "content": "Show me all insurance plans where the website includes 'secure'."}, {"role": "assistant", "content": "SELECT * FROM healthcare.insurance_plans WHERE website ILIKE '%secure%';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.doctors ( doctor_id text, first_name text, last_name text, specialty text, license_number text, phone_number text, email text, hospital_affiliation_id text, created_at timestamp, updated_at timestamp )\nCREATE 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 )\nCREATE TABLE healthcare.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )\nCREATE TABLE healthcare.patient_insurance ( patient_insurance_id text, patient_id text, plan_id text, policy_number text, group_number text, subscriber_name text, effective_date date, expiration_date date, is_primary boolean )\n"}
{"conversations": [{"role": "user", "content": "List all staff members who have responded to at least one review in the last 6 months, including their first and last names and the count of responses."}, {"role": "assistant", "content": "SELECT s.staff_id, s.first_name, s.last_name, COUNT(r.review_id) AS response_count\nFROM hospitality_technology.reviews AS r\nJOIN hospitality_technology.staff AS s\n  ON r.response_staff_id = s.staff_id\nWHERE r.response_date >= CURRENT_DATE - INTERVAL '6 months'\nGROUP BY s.staff_id, s.first_name, s.last_name;"}, {"role": "user", "content": "Actually, only include responses to public reviews."}, {"role": "assistant", "content": "SELECT s.staff_id, s.first_name, s.last_name, COUNT(r.review_id) AS response_count\nFROM hospitality_technology.reviews AS r\nJOIN hospitality_technology.staff AS s\n  ON r.response_staff_id = s.staff_id\nWHERE r.response_date >= CURRENT_DATE - INTERVAL '6 months'\n  AND r.is_public = TRUE\nGROUP BY s.staff_id, s.first_name, s.last_name;"}, {"role": "user", "content": "Also include the average response time in days for each staff member."}, {"role": "assistant", "content": "SELECT s.staff_id, s.first_name, s.last_name,\n       COUNT(r.review_id) AS response_count,\n       AVG(EXTRACT(EPOCH FROM (r.response_date - r.review_date)) / 86400) AS avg_response_days\nFROM hospitality_technology.reviews AS r\nJOIN hospitality_technology.staff AS s\n  ON r.response_staff_id = s.staff_id\nWHERE r.response_date >= CURRENT_DATE - INTERVAL '6 months'\n  AND r.is_public = TRUE\nGROUP BY s.staff_id, s.first_name, s.last_name;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties (\n    property_id character varying(64) NOT NULL,  -- unique identifier for the property (hotel, resort, etc.)\n    property_name character varying(255) NOT NULL, -- name of the property\n    address_line1 character varying(255) NOT NULL, -- primary address line\n    address_line2 character varying(255), -- secondary address line\n    city character varying(100) NOT NULL, -- city\n    state_province character varying(100), -- state or province\n    postal_code character varying(20) NOT NULL, -- zip or postal code\n    country_code character varying(3) NOT NULL, -- ISO country code (e.g., USA, CAN)\n    phone_number character varying(30), -- main contact phone\n    email_address character varying(255), -- main contact email\n    property_type character varying(50) NOT NULL, -- e.g., Hotel, Resort, B&B, Motel\n    star_rating numeric(2,1), -- star rating (e.g., 4.5)\n    timezone character varying(64) NOT NULL, -- IANA timezone ID (e.g., America/New_York)\n    manager_staff_id character varying(64), -- FK to staff table for the general manager\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record creation time\n    updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record last update time\n    PRIMARY KEY (property_id)\n)\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Find all pairs of users where the registration times are within 30 minutes of each other, and show both user IDs, usernames, and the time difference in minutes."}, {"role": "assistant", "content": "SELECT u1.user_id AS user1_id, u1.username AS user1_name, u2.user_id AS user2_id, u2.username AS user2_name, ROUND(ABS(EXTRACT(EPOCH FROM u1.created_at - u2.created_at))/60,2) AS diff_minutes FROM web3.users u1 JOIN web3.users u2 ON u1.user_id < u2.user_id WHERE ABS(EXTRACT(EPOCH FROM u1.created_at - u2.created_at))/60 <= 30;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.users ( user_id.text, username.text, email.text, password_hash.text, created_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "What are the specific tools or equipment used during the maintenance with record_id 'REC456'?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information about the specific tools or equipment used during a maintenance record. The data in the maintenance_records table does not include details about tools or equipment used."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.maintenance_records ( record_id text PRIMARY KEY, asset_id text, asset_type text, maintenance_type text, staff_id text, start_datetime timestamp, end_datetime timestamp, description text, cost numeric, status text )\n"}
{"conversations": [{"role": "user", "content": "Show me the number of game servers in each region and the average maximum number of players they can accommodate. Exclude any servers that are currently offline."}, {"role": "assistant", "content": "SELECT region, COUNT(server_id) AS server_count, AVG(max_players) AS average_max_players FROM gaming_technology.servers WHERE status != 'offline' GROUP BY region;"}, {"role": "user", "content": "Please filter the results to only include regions that have more than 5 active servers."}, {"role": "assistant", "content": "SELECT region, COUNT(server_id) AS server_count, AVG(max_players) AS average_max_players FROM gaming_technology.servers WHERE status != 'offline' GROUP BY region HAVING COUNT(server_id) > 5;"}, {"role": "user", "content": "Can you also include the total number of current players across all active servers in each of those regions?"}, {"role": "assistant", "content": "SELECT region, COUNT(server_id) AS server_count, AVG(max_players) AS average_max_players, SUM(current_players) AS total_current_players FROM gaming_technology.servers WHERE status != 'offline' GROUP BY region HAVING COUNT(server_id) > 5;"}, {"role": "user", "content": "Order the final results by the total number of current players in descending order."}, {"role": "assistant", "content": "SELECT region, COUNT(server_id) AS server_count, AVG(max_players) AS average_max_players, SUM(current_players) AS total_current_players FROM gaming_technology.servers WHERE status != 'offline' GROUP BY region HAVING COUNT(server_id) > 5 ORDER BY total_current_players DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.players (\n    player_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the player\n    username character varying(100) NOT NULL UNIQUE, -- player's chosen display name\n    email character varying(255) NOT NULL UNIQUE, -- player's email address for login/recovery\n    password_hash text NOT NULL, -- securely hashed password\n    registration_date timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the player account was created\n    last_login timestamp with time zone, -- timestamp of the last successful login\n    country_code character(2), -- player's country (ISO 3166-1 alpha-2)\n    status character varying(20) NOT NULL DEFAULT 'active', -- account status (e.g., active, banned, suspended)\n    profile_data jsonb, -- flexible field for avatar url, bio, preferences etc.\n    PRIMARY KEY (player_id)\n)\nCREATE TABLE gaming_technology.games (\n    game_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game\n    title character varying(200) NOT NULL, -- official title of the game\n    developer_id uuid NOT NULL, -- FK linking to the developers table\n    publisher_id uuid, -- FK linking to a potential publishers table (optional)\n    genre character varying(100), -- primary genre (e.g., RPG, FPS, Strategy)\n    release_date date, -- official release date\n    description text, -- short description or synopsis of the game\n    platform character varying(50) NOT NULL, -- primary platform (e.g., PC, PlayStation 5, Xbox Series X, Mobile)\n    engine character varying(100), -- game engine used (e.g., Unreal Engine 5, Unity)\n    website character varying(255), -- official website URL\n    PRIMARY KEY (game_id)\n    -- FOREIGN KEY (developer_id) REFERENCES gaming_technology.developers(developer_id) -- Example FK constraint\n)\nCREATE TABLE gaming_technology.game_sessions (\n    session_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game session\n    player_id uuid NOT NULL, -- FK linking to the players table\n    game_id uuid NOT NULL, -- FK linking to the games table\n    server_id uuid, -- FK linking to the servers table (nullable for single-player)\n    start_time timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the session began\n    end_time timestamp with time zone, -- when the session ended (null if ongoing)\n    duration_seconds integer, -- calculated duration of the session in seconds\n    score integer, -- player's score for the session, if applicable\n    session_data jsonb, -- flexible field for session-specific info (e.g., map played, character used)\n    PRIMARY KEY (session_id)\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id),\n    -- FOREIGN KEY (server_id) REFERENCES gaming_technology.servers(server_id)\n)\nCREATE TABLE gaming_technology.servers (\n    server_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game server instance\n    game_id uuid NOT NULL, -- FK linking to the game this server hosts\n    server_name character varying(150), -- display name for the server\n    region character varying(50) NOT NULL, -- geographical region (e.g., us-east-1, eu-west-2)\n    ip_address character varying(45), -- IP address (IPv4 or IPv6)\n    port integer, -- network port number\n    current_players integer NOT NULL DEFAULT 0, -- number of players currently connected\n    max_players integer NOT NULL, -- maximum player capacity\n    status character varying(30) NOT NULL DEFAULT 'offline', -- server status (e.g., online, offline, maintenance)\n    last_heartbeat timestamp with time zone, -- last time the server reported its status\n    PRIMARY KEY (server_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.achievements (\n    achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an achievement definition\n    game_id uuid NOT NULL, -- FK linking to the game the achievement belongs to\n    name character varying(150) NOT NULL, -- name of the achievement\n    description text NOT NULL, -- how to unlock the achievement\n    icon_url character varying(255), -- URL for the achievement's icon\n    points integer DEFAULT 0, -- points awarded for unlocking (optional)\n    hidden boolean DEFAULT false, -- whether the achievement details are hidden until unlocked\n    PRIMARY KEY (achievement_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.player_achievements (\n    player_achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for this unlock instance\n    player_id uuid NOT NULL, -- FK linking to the player who unlocked it\n    achievement_id uuid NOT NULL, -- FK linking to the achievement definition\n    unlocked_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the achievement was unlocked\n    PRIMARY KEY (player_achievement_id),\n    UNIQUE (player_id, achievement_id) -- Ensure a player can only unlock an achievement once\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (achievement_id) REFERENCES gaming_technology.achievements(achievement_id)\n)\nCREATE TABLE gaming_technology.in_game_items (\n    item_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the item definition\n    game_id uuid NOT NULL, -- FK linking to the game this item belongs to\n    item_name character varying(150) NOT NULL, -- name of the item\n    item_type character varying(50) NOT NULL, -- type (e.g., Cosmetic, Consumable, Weapon, Armor)\n    description text, -- description of the item\n    rarity character varying(30), -- item rarity (e.g., Common, Rare, Epic, Legendary)\n    cost_currency character varying(10), -- currency code if purchasable (e.g., USD, EUR, GOLD)\n    cost_amount numeric(12, 2), -- price if purchasable\n    attributes jsonb, -- flexible field for item stats or properties\n    PRIMARY KEY (item_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.player_inventory (\n    inventory_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an inventory entry\n    player_id uuid NOT NULL, -- FK linking to the player owning the item\n    item_id uuid NOT NULL, -- FK linking to the item definition\n    quantity integer NOT NULL DEFAULT 1, -- number of items held (for stackable items)\n    acquired_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the item was acquired\n    instance_data jsonb, -- data specific to this instance (e.g., weapon mods, durability)\n    PRIMARY KEY (inventory_id),\n    -- Optional unique constraint if items are non-stackable or unique instances\n    -- UNIQUE (player_id, item_id) -- Use if quantity is always 1\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (item_id) REFERENCES gaming_technology.in_game_items(item_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Find all wallets that hold at least one NFT and also hold ERC-20 tokens."}, {"role": "assistant", "content": "SELECT DISTINCT nh.wallet_address\nFROM nft_holders nh\nJOIN erc20_balances eb\n  ON nh.wallet_address = eb.wallet_address;"}, {"role": "user", "content": "Now show the count of distinct NFTs and count of distinct ERC-20 token contracts held by each such wallet."}, {"role": "assistant", "content": "SELECT nh.wallet_address,\n       COUNT(DISTINCT nh.contract_address || '-' || nh.token_id) AS nft_count,\n       COUNT(DISTINCT eb.contract_address) AS erc20_count\nFROM nft_holders nh\nJOIN erc20_balances eb\n  ON nh.wallet_address = eb.wallet_address\nGROUP BY nh.wallet_address;"}, {"role": "user", "content": "Finally, only include wallets where erc20_count > 1 and nft_count > 2, and order by erc20_count descending."}, {"role": "assistant", "content": "SELECT nh.wallet_address,\n       COUNT(DISTINCT nh.contract_address || '-' || nh.token_id) AS nft_count,\n       COUNT(DISTINCT eb.contract_address) AS erc20_count\nFROM nft_holders nh\nJOIN erc20_balances eb\n  ON nh.wallet_address = eb.wallet_address\nGROUP BY nh.wallet_address\nHAVING COUNT(DISTINCT eb.contract_address) > 1\n   AND COUNT(DISTINCT nh.contract_address || '-' || nh.token_id) > 2\nORDER BY erc20_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE erc20_balances ( block_number.bigint, contract_address.text, wallet_address.text, amount.text, pk.text )\nCREATE TABLE nft_holders (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    contract_address varchar NOT NULL, -- Event contract address\n    wallet_address varchar NOT NULL, -- The wallet address for the contract(with bloom filter)\n    token_id varchar NOT NULL, -- NFT token id\n    contract_type varchar NOT NULL, -- NFT contract type\n    amount varchar NOT NULL, -- Number of held NFTs\n    pk varchar NOT NULL  -- The last string partition of the contract.\n)\nCREATE TABLE sui_nfts ( object_id varchar, status varchar, collection_type varchar, package_id varchar, previous_transaction varchar, display varchar, owner varchar, name varchar )\nCREATE TABLE token_prices ( uuid varchar, blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE token_prices_latest (\n    blockchain varchar(36) NOT NULL, -- blockchain fields for the functionType  in contract\n    address varchar(42) NOT NULL, -- address fields for the functionType  in contract\n    decimals bigint NOT NULL, -- decimals fields for the functionType  in contract\n    symbol varchar(36) NOT NULL, -- symbol fields for the functionType  in contract\n    price real NOT NULL, -- price fields for the functionType  in contract\n    timestamp timestamp(6) NOT NULL  -- timestamp fields for the functionType  in contract\n)\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash text, log_index integer, contract_address text, pk integer )\nCREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\nCREATE TABLE token_info (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    tick varchar NOT NULL, -- Token tick\n    max_supply decimal(38,0) NOT NULL, -- Max supply\n    lim decimal(38,0) NOT NULL, -- Limit of each mint\n    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint\n    dec integer NOT NULL, -- Decimal for minimum divie\n    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)\n)\nCREATE TABLE token_info_bitcoin ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar(255) NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL )\nCREATE TABLE token_activities_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(42) NOT NULL, to_address varchar(42) NOT NULL )\nCREATE TABLE token_balances_avalanche ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\n"}
{"conversations": [{"role": "user", "content": "What is the number of guests per country, grouped by country_code?"}, {"role": "assistant", "content": "SELECT country_code,\n       COUNT(*) AS guest_count\nFROM hospitality_technology.guests\nGROUP BY country_code;"}, {"role": "user", "content": "Only include countries that have at least 5 guests."}, {"role": "assistant", "content": "SELECT country_code,\n       COUNT(*) AS guest_count\nFROM hospitality_technology.guests\nGROUP BY country_code\nHAVING COUNT(*) >= 5;"}, {"role": "user", "content": "Also include the most recently registered guest in each of those countries, showing their full name and created_at."}, {"role": "assistant", "content": "WITH country_counts AS (\n  SELECT country_code,\n         COUNT(*) AS guest_count,\n         MAX(created_at) AS last_reg\n  FROM hospitality_technology.guests\n  GROUP BY country_code\n  HAVING COUNT(*) >= 5\n)\nSELECT cc.country_code,\n       cc.guest_count,\n       g.first_name || ' ' || g.last_name AS last_guest_name,\n       g.created_at          AS last_registration\nFROM country_counts cc\nJOIN hospitality_technology.guests g\n  ON g.country_code = cc.country_code\n AND g.created_at = cc.last_reg;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.guests ( guest_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, email character varying(255) UNIQUE, phone_number character varying(30), date_of_birth date, address_line1 character varying(255), city character varying(100), state_province character varying(100), postal_code character varying(20), country_code character varying(3), preferences text, loyalty_member_id character varying(64) UNIQUE, communication_consent boolean DEFAULT true, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (guest_id) )\n"}
{"conversations": [{"role": "user", "content": "Give me each server's name, the region, and the maximum number of players that have been connected at once."}, {"role": "assistant", "content": "SELECT s.server_id, s.server_name, s.region, MAX(s.current_players) AS max_players_seen\nFROM gaming_technology.servers s\nGROUP BY s.server_id, s.server_name, s.region;"}, {"role": "user", "content": "Could you also include the associated game title for each server?"}, {"role": "assistant", "content": "SELECT s.server_id, s.server_name, s.region, g.title AS game_title, MAX(s.current_players) AS max_players_seen\nFROM gaming_technology.servers s\nJOIN gaming_technology.games g ON s.game_id = g.game_id\nGROUP BY s.server_id, s.server_name, s.region, g.title;"}, {"role": "user", "content": "Now, can you show only servers where the max number of players ever connected exceeded 20?"}, {"role": "assistant", "content": "SELECT s.server_id, s.server_name, s.region, g.title AS game_title, MAX(s.current_players) AS max_players_seen\nFROM gaming_technology.servers s\nJOIN gaming_technology.games g ON s.game_id = g.game_id\nGROUP BY s.server_id, s.server_name, s.region, g.title\nHAVING MAX(s.current_players) > 20;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.players ( player_id uuid PRIMARY KEY, username text, email text, password_hash text, registration_date timestamptz, last_login timestamptz, country_code text, status text, profile_data jsonb )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE gaming_technology.servers (\n    server_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game server instance\n    game_id uuid NOT NULL, -- FK linking to the game this server hosts\n    server_name character varying(150), -- display name for the server\n    region character varying(50) NOT NULL, -- geographical region (e.g., us-east-1, eu-west-2)\n    ip_address character varying(45), -- IP address (IPv4 or IPv6)\n    port integer, -- network port number\n    current_players integer NOT NULL DEFAULT 0, -- number of players currently connected\n    max_players integer NOT NULL, -- maximum player capacity\n    status character varying(30) NOT NULL DEFAULT 'offline', -- server status (e.g., online, offline, maintenance)\n    last_heartbeat timestamp with time zone, -- last time the server reported its status\n    PRIMARY KEY (server_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.achievements ( achievement_id.uuid, game_id.uuid, name.text, description.text, icon_url.text, points.integer, hidden.boolean )\nCREATE TABLE gaming_technology.player_achievements ( player_achievement_id.uuid, player_id.uuid, achievement_id.uuid, unlocked_at.timestamptz )\nCREATE 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) )\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "How many verified users are there?"}, {"role": "assistant", "content": "SELECT COUNT(user_id) FROM social_media.users WHERE is_verified = TRUE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE social_media.posts ( post_id text, 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 )\nCREATE TABLE social_media.comments ( comment_id text PRIMARY KEY, post_id text, user_id text, parent_comment_id text, content text, created_at timestamp, updated_at timestamp )\nCREATE TABLE social_media.likes ( like_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, post_id character varying(64), comment_id character varying(64), created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (like_id), CONSTRAINT unique_user_like UNIQUE (user_id, post_id, comment_id), CONSTRAINT check_like_target CHECK (post_id IS NOT NULL OR comment_id IS NOT NULL) )\nCREATE TABLE social_media.follows ( follow_id.text, follower_user_id.text, following_user_id.text, created_at.timestamp )\nCREATE TABLE social_media.hashtags ( hashtag_id text PRIMARY KEY, tag_name text, created_at timestamp )\nCREATE TABLE social_media.post_hashtags ( post_hashtag_id character varying(64) NOT NULL, post_id character varying(64) NOT NULL, hashtag_id character varying(64) NOT NULL, PRIMARY KEY (post_hashtag_id), CONSTRAINT unique_post_hashtag UNIQUE (post_id, hashtag_id) )\nCREATE TABLE social_media.conversations ( conversation_id.text, created_at.timestamp, last_message_at.timestamp, is_group_chat.boolean, group_name.text )\nCREATE TABLE social_media.conversation_participants ( participant_id.text, conversation_id.text, user_id.text, joined_at.timestamp, last_read_at.timestamp )\nCREATE TABLE social_media.notifications ( notification_id text PRIMARY KEY, recipient_user_id text, sender_user_id text, notification_type text, target_entity_id text, target_entity_type text, created_at timestamp, read_at timestamp )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "For each group chat, can you show me each participant's username and the date they joined the chat?"}, {"role": "assistant", "content": "SELECT u.username, c.group_name, cp.joined_at\nFROM social_media.conversation_participants cp\nJOIN social_media.users u ON cp.user_id = u.user_id\nJOIN social_media.conversations c ON cp.conversation_id = c.conversation_id\nWHERE c.is_group_chat = true;"}, {"role": "user", "content": "Can you also include the total number of participants for each group chat in the result?"}, {"role": "assistant", "content": "SELECT u.username, c.group_name, cp.joined_at, COUNT(cp2.participant_id) AS total_participants\nFROM social_media.conversation_participants cp\nJOIN social_media.users u ON cp.user_id = u.user_id\nJOIN social_media.conversations c ON cp.conversation_id = c.conversation_id\nJOIN social_media.conversation_participants cp2 ON cp2.conversation_id = cp.conversation_id\nWHERE c.is_group_chat = true\nGROUP BY u.username, c.group_name, cp.joined_at;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE social_media.posts ( post_id text, 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 )\nCREATE TABLE social_media.comments ( comment_id text, post_id text, user_id text, parent_comment_id text, content text, created_at timestamp, updated_at timestamp )\nCREATE TABLE social_media.follows ( follow_id text, follower_user_id text, following_user_id text, created_at timestamp )\nCREATE TABLE social_media.post_hashtags ( post_hashtag_id text, post_id text, hashtag_id text )\nCREATE TABLE social_media.messages ( message_id text, conversation_id text, sender_user_id text, content text, media_url text, media_type text, sent_at timestamp, read_at timestamp )\nCREATE TABLE social_media.conversation_participants ( participant_id text, conversation_id text, user_id text, joined_at timestamp, last_read_at timestamp )\nCREATE 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 )\nCREATE TABLE social_media.user_settings ( setting_id text, user_id text, theme text, email_notifications_enabled boolean, push_notifications_enabled boolean, private_profile boolean, updated_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Find the average percentage share among all beneficiaries for each distinct relationship type."}, {"role": "assistant", "content": "SELECT relationship, AVG(percentage_share) FROM insurance.policy_beneficiaries GROUP BY relationship ORDER BY relationship;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.insurance_products ( product_id.text, 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all ERC20 tokens where the price is between $1 and $10, including their names, symbols, and contract addresses."}, {"role": "assistant", "content": "SELECT name, symbol, address FROM token_prices_latest WHERE price BETWEEN 1 AND 10 AND blockchain = 'ethereum';"}, {"role": "user", "content": "I think there's an error in your query - it should be joining with sui_coins_metadata on coin_type not address. Also, can you add the current price to the results?"}, {"role": "assistant", "content": "SELECT scm.name, scm.symbol, scm.coin_type, tpl.price FROM sui_coins_metadata scm JOIN token_prices_latest tpl ON scm.coin_type = tpl.address WHERE tpl.price BETWEEN 1 AND 10;"}, {"role": "user", "content": "Now filter these results to only show tokens with decimals equal to 18 and sort by name alphabetically."}, {"role": "assistant", "content": "SELECT scm.name, scm.symbol, scm.coin_type, tpl.price FROM sui_coins_metadata scm JOIN token_prices_latest tpl ON scm.coin_type = tpl.address WHERE tpl.price BETWEEN 1 AND 10 AND scm.decimals = 18 ORDER BY scm.name ASC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE erc1155_approval_for_all (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction\n    transaction_index integer NOT NULL, -- Index of the transaction within the block\n    transaction_hash varchar(66) NOT NULL, -- Transaction hash\n    log_index integer NOT NULL, -- Log index\n    contract_address varchar(42) NOT NULL  -- Event contract address\n)\nCREATE TABLE nft_holder_historical (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    contract_address varchar NOT NULL, -- Event contract address\n    wallet_address varchar NOT NULL, -- The wallet address for the contract(with bloom filter)\n    token_id varchar NOT NULL, -- NFT token id\n    contract_type varchar NOT NULL, -- NFT contract type\n    amount varchar NOT NULL, -- The quantity held in the wallet\n    pk integer NOT NULL  -- Partition key for the table(floor(block_number / 7200))\n)\nCREATE TABLE sui_coins_metadata ( object_id varchar, coin_type varchar, status varchar, decimals bigint, description varchar, icon_url varchar, symbol varchar, name varchar )\nCREATE TABLE sui_nfts (\n    object_id varchar NOT NULL, -- object id of the nft\n    status varchar NOT NULL, -- status of the package, exists or deleted\n    collection_type varchar NOT NULL, -- collection type of the nft, eg. 0x...123::avatars::Avatar\n    package_id varchar NOT NULL, -- which package the nft belongs to, eg. 0x...123::avatars belongs to 0x...123\n    previous_transaction varchar NOT NULL, -- previous transaction of the nft\n    display varchar NOT NULL, -- nft metadata json object\n    owner varchar NOT NULL, -- nft owner\n    name varchar NOT NULL  -- nft name\n)\nCREATE TABLE nft_metadata (\n    blockchain varchar NOT NULL, -- blockchain fields for the functionType  in contract\n    contract_address varchar NOT NULL, -- Contract address(with bloom filter)\n    token_id varchar NOT NULL, -- The number of the token\n    contract_name varchar NOT NULL, -- contract_name fields for the functionType  in contract\n    erc_type varchar NOT NULL, -- The type of token\n    amount bigint NOT NULL, -- amount fields for the functionType  in contract\n    minter varchar NOT NULL, -- minter fields for the functionType  in contract\n    owner varchar NOT NULL, -- owner fields for the functionType  in contract\n    mint_block_number bigint NOT NULL, -- mint_block_number fields for the functionType  in contract\n    mint_time bigint NOT NULL, -- mint_time fields for the functionType  in contract\n    mint_transaction_hash varchar NOT NULL, -- mint_transaction_hash fields for the functionType  in contract\n    mint_price varchar NOT NULL, -- mint_price fields for the functionType  in contract\n    token_uri varchar NOT NULL, -- token_uri fields for the functionType  in contract\n    metadata varchar NOT NULL, -- metadata fields for the functionType  in contract\n    name varchar NOT NULL, -- name fields for the functionType  in contract\n    image_uri varchar NOT NULL, -- image_uri fields for the functionType  in contract\n    traits varchar NOT NULL, -- traits fields for the functionType  in contract\n    updated_at bigint NOT NULL, -- updated_at fields for the functionType  in contract\n    status varchar NOT NULL, -- status fields for the functionType  in contract\n    rarity_score real NOT NULL, -- rarity_score fields for the functionType  in contract\n    rarity_rank integer NOT NULL, -- rarity_rank fields for the functionType  in contract\n    unique_attribute_count integer NOT NULL, -- unique_attribute_count fields for the functionType  in contract\n    pk integer NOT NULL  -- Partition key for the table(floor(mint_time / 1000 / 86400 / 30))\n)\nCREATE TABLE token_prices ( uuid varchar(36) NOT NULL, blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )\nCREATE TABLE token_prices_latest ( blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE token_balances (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar NOT NULL, -- Token tick\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply decimal(38,0) NOT NULL, -- Max supply\n    amount decimal(38,0) NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE TABLE token_balances_bitcoin ( block_number.bigint, block_timestamp.timestamp, tick.text, wallet_address.text, total_supply.text, amount.text )\nCREATE TABLE token_activities_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(42) NOT NULL, to_address varchar(42) NOT NULL )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "For each booking, show the booking_id, seat_number, fare, and the city of the origin location for the trip that was booked."}, {"role": "assistant", "content": "SELECT b.booking_id, b.seat_number, b.fare, orig.city AS origin_city\nFROM transportation.bookings b\nJOIN transportation.trips t ON b.trip_id = t.trip_id\nJOIN transportation.routes r ON t.route_id = r.route_id\nJOIN transportation.locations orig ON r.origin_location_id = orig.location_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.drivers ( driver_id character varying(64) NOT NULL, employee_id character varying(64) NOT NULL UNIQUE, first_name character varying(128) NOT NULL, last_name character varying(128) NOT NULL, license_number character varying(64) NOT NULL UNIQUE, license_expiry_date date NOT NULL, contact_number character varying(32), email character varying(128) UNIQUE, hire_date date NOT NULL, status character varying(32) NOT NULL, PRIMARY KEY (driver_id) )\nCREATE TABLE transportation.routes ( route_id character varying(64) NOT NULL, route_number character varying(32) NOT NULL UNIQUE, description text, origin_location_id character varying(64) NOT NULL, destination_location_id character varying(64) NOT NULL, distance_km numeric(10, 2), estimated_duration_minutes integer, type character varying(32) NOT NULL, PRIMARY KEY (route_id) )\nCREATE TABLE transportation.locations ( location_id character varying(64) NOT NULL, name character varying(255) NOT NULL, type character varying(64) NOT NULL, address_line1 character varying(255), city character varying(128), state_province character varying(128), postal_code character varying(32), country character varying(64) NOT NULL, latitude numeric(9, 6), longitude numeric(9, 6), timezone character varying(64), PRIMARY KEY (location_id) )\nCREATE TABLE transportation.maintenance_logs ( log_id character varying(64) NOT NULL, vehicle_id character varying(64) NOT NULL, service_date date NOT NULL, odometer_reading integer, service_type character varying(128) NOT NULL, description text NOT NULL, cost numeric(10, 2), mechanic_name character varying(128), next_service_due_date date, PRIMARY KEY (log_id) )\nCREATE TABLE transportation.bookings ( booking_id character varying(64) NOT NULL, passenger_id character varying(64) NOT NULL, trip_id character varying(64) NOT NULL, seat_number character varying(16), booking_time timestamp with time zone NOT NULL, status character varying(32) NOT NULL, fare numeric(10, 2) NOT NULL, payment_transaction_id character varying(128), special_requests text, PRIMARY KEY (booking_id) )\n"}
{"conversations": [{"role": "user", "content": "Show the appointment ID, scheduled start time, and the full name of the citizen for all appointments related to services with a standard fee greater than 150."}, {"role": "assistant", "content": "SELECT a.appointment_id, a.scheduled_start_time, c.first_name || ' ' || c.last_name AS full_name\nFROM government_services.appointments a\nJOIN government_services.citizens c ON a.citizen_id = c.citizen_id\nJOIN government_services.payments p ON a.citizen_id = p.citizen_id AND a.service_id = p.service_id\nWHERE p.amount > 150;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id text PRIMARY KEY, 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all fuel refueling events with the refueled vehicle's make and model, the fuel type used, and the fueling location ID."}, {"role": "assistant", "content": "SELECT fl.fuel_log_id, fl.log_timestamp, v.make, v.model, fl.fuel_type, fl.quantity, fl.unit, fl.total_cost, fl.location_id\nFROM transportation.fuel_logs fl\nJOIN transportation.vehicles v ON fl.vehicle_id = v.vehicle_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE transportation.drivers ( driver_id.text, 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 )\nCREATE TABLE transportation.routes ( route_id text, route_number text, description text, origin_location_id text, destination_location_id text, distance_km numeric, estimated_duration_minutes integer, type text )\nCREATE TABLE transportation.trips ( trip_id text, route_id text, vehicle_id text, driver_id text, scheduled_departure timestamp, actual_departure timestamp, scheduled_arrival timestamp, actual_arrival timestamp, origin_location_id text, destination_location_id text, status text, passenger_count integer, cargo_manifest_id text )\nCREATE TABLE transportation.maintenance_logs (\n    log_id character varying(64) NOT NULL,  -- unique identifier for the maintenance record\n    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle serviced\n    service_date date NOT NULL, -- date the service was performed\n    odometer_reading integer, -- vehicle mileage at time of service\n    service_type character varying(128) NOT NULL, -- type of service (e.g., Oil Change, Tire Rotation, Engine Repair)\n    description text NOT NULL, -- detailed description of work done\n    cost numeric(10, 2), -- cost of the service\n    mechanic_name character varying(128), -- name or ID of the mechanic/shop\n    next_service_due_date date, -- recommended date for next service\n    PRIMARY KEY (log_id)\n)\nCREATE TABLE transportation.fuel_logs (\n    fuel_log_id character varying(64) NOT NULL,  -- unique identifier for the fuel log entry\n    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle fueled\n    trip_id character varying(64), -- optional: identifier of the trip during which fueling occurred\n    log_timestamp timestamp with time zone NOT NULL, -- time when fueling occurred\n    fuel_type character varying(32) NOT NULL, -- type of fuel added (matches vehicle's fuel type)\n    quantity numeric(10, 3) NOT NULL, -- amount of fuel added (e.g., Liters, Gallons, kWh)\n    unit character varying(16) NOT NULL, -- unit of quantity (e.g., L, gal, kWh)\n    cost_per_unit numeric(8, 4), -- price per unit of fuel\n    total_cost numeric(10, 2) NOT NULL, -- total cost of the fuel purchase\n    odometer_reading integer, -- vehicle mileage at time of fueling\n    location_id character varying(64), -- identifier of the fueling station/location\n    PRIMARY KEY (fuel_log_id)\n)\nCREATE TABLE transportation.bookings ( booking_id character varying(64) NOT NULL, passenger_id character varying(64) NOT NULL, trip_id character varying(64) NOT NULL, seat_number character varying(16), booking_time timestamp with time zone NOT NULL, status character varying(32) NOT NULL, fare numeric(10, 2) NOT NULL, payment_transaction_id character varying(128), special_requests text, PRIMARY KEY (booking_id) )\n"}
{"conversations": [{"role": "user", "content": "Count the number of assets for each asset type."}, {"role": "assistant", "content": "SELECT type, COUNT(*) FROM trading_platform.assets GROUP BY type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.users ( user_id character varying(64) NOT NULL, username character varying(128) NOT NULL, email character varying(128) NOT NULL, password_hash text NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (user_id) )\nCREATE TABLE trading_platform.assets ( asset_id character varying(64) NOT NULL, name character varying(128) NOT NULL, symbol character varying(32) NOT NULL, type character varying(32) NOT NULL, PRIMARY KEY (asset_id) )\nCREATE TABLE trading_platform.metadata ( metadata_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, key character varying(128) NOT NULL, value text NOT NULL, PRIMARY KEY (metadata_id) )\nCREATE TABLE trading_platform.kyc_audit ( kyc_audit_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, status character varying(32) NOT NULL, reviewed_at timestamp NOT NULL, PRIMARY KEY (kyc_audit_id) )\n"}
{"conversations": [{"role": "user", "content": "List pairs of documents uploaded by the same user for the same claim. Return uploaded_by, claim_id, document_id AS doc1_id, and the paired document_id AS doc2_id."}, {"role": "assistant", "content": "SELECT cd1.uploaded_by,\n       cd1.claim_id,\n       cd1.document_id AS doc1_id,\n       cd2.document_id AS doc2_id\nFROM insurance.claim_documents cd1\nJOIN insurance.claim_documents cd2\n  ON cd1.claim_id = cd2.claim_id\n AND cd1.uploaded_by = cd2.uploaded_by\n AND cd1.document_id < cd2.document_id;"}, {"role": "user", "content": "Filter to only include pairs where the two documents have different mime_types."}, {"role": "assistant", "content": "SELECT cd1.uploaded_by,\n       cd1.claim_id,\n       cd1.document_id AS doc1_id,\n       cd2.document_id AS doc2_id\nFROM insurance.claim_documents cd1\nJOIN insurance.claim_documents cd2\n  ON cd1.claim_id = cd2.claim_id\n AND cd1.uploaded_by = cd2.uploaded_by\n AND cd1.document_id < cd2.document_id\nWHERE cd1.mime_type <> cd2.mime_type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all auto loans (loan_id, principal_amount, interest_rate) where the current principal balance is less than 40% of the original principal amount, along with the account_id and the difference between principal_amount and current_principal_balance."}, {"role": "assistant", "content": "SELECT loan_id, principal_amount, interest_rate, account_id, (principal_amount - current_principal_balance) AS amount_paid FROM financial_services.loans WHERE loan_type = 'Auto' AND current_principal_balance < (0.4 * principal_amount);"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "What is the total count of game sessions recorded?"}, {"role": "assistant", "content": "SELECT count(*) FROM gaming_technology.game_sessions;"}, {"role": "user", "content": "Now, only count sessions that lasted longer than 1 hour."}, {"role": "assistant", "content": "SELECT count(*) FROM gaming_technology.game_sessions WHERE duration_seconds > 3600;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.games (\n    game_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game\n    title character varying(200) NOT NULL, -- official title of the game\n    developer_id uuid NOT NULL, -- FK linking to the developers table\n    publisher_id uuid, -- FK linking to a potential publishers table (optional)\n    genre character varying(100), -- primary genre (e.g., RPG, FPS, Strategy)\n    release_date date, -- official release date\n    description text, -- short description or synopsis of the game\n    platform character varying(50) NOT NULL, -- primary platform (e.g., PC, PlayStation 5, Xbox Series X, Mobile)\n    engine character varying(100), -- game engine used (e.g., Unreal Engine 5, Unity)\n    website character varying(255), -- official website URL\n    PRIMARY KEY (game_id)\n    -- FOREIGN KEY (developer_id) REFERENCES gaming_technology.developers(developer_id) -- Example FK constraint\n)\nCREATE TABLE gaming_technology.game_sessions ( session_id uuid, player_id uuid, game_id uuid, server_id uuid, start_time timestamp with time zone, end_time timestamp with time zone, duration_seconds integer, score integer, session_data jsonb )\nCREATE TABLE gaming_technology.servers ( server_id uuid, game_id uuid, server_name text, region text, ip_address text, port integer, current_players integer, max_players integer, status text, last_heartbeat timestamp with time zone )\nCREATE TABLE gaming_technology.in_game_items (\n    item_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the item definition\n    game_id uuid NOT NULL, -- FK linking to the game this item belongs to\n    item_name character varying(150) NOT NULL, -- name of the item\n    item_type character varying(50) NOT NULL, -- type (e.g., Cosmetic, Consumable, Weapon, Armor)\n    description text, -- description of the item\n    rarity character varying(30), -- item rarity (e.g., Common, Rare, Epic, Legendary)\n    cost_currency character varying(10), -- currency code if purchasable (e.g., USD, EUR, GOLD)\n    cost_amount numeric(12, 2), -- price if purchasable\n    attributes jsonb, -- flexible field for item stats or properties\n    PRIMARY KEY (item_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me the average, maximum, and minimum points for all achievements."}, {"role": "assistant", "content": "SELECT AVG(points) AS average_points, MAX(points) AS maximum_points, MIN(points) AS minimum_points FROM gaming_technology.achievements;"}, {"role": "user", "content": "Can you break this down by whether the achievement is hidden or not?"}, {"role": "assistant", "content": "SELECT hidden, AVG(points) AS average_points, MAX(points) AS maximum_points, MIN(points) AS minimum_points FROM gaming_technology.achievements GROUP BY hidden;"}, {"role": "user", "content": "Exclude achievements with zero points from this calculation."}, {"role": "assistant", "content": "SELECT hidden, AVG(points) AS average_points, MAX(points) AS maximum_points, MIN(points) AS minimum_points FROM gaming_technology.achievements WHERE points > 0 GROUP BY hidden;"}, {"role": "user", "content": "Also, include the count of achievements in each group."}, {"role": "assistant", "content": "SELECT hidden, COUNT(achievement_id) AS achievement_count, AVG(points) AS average_points, MAX(points) AS maximum_points, MIN(points) AS minimum_points FROM gaming_technology.achievements WHERE points > 0 GROUP BY hidden;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE gaming_technology.developers ( developer_id uuid PRIMARY KEY, name text, country text, founded_year int, website text, created_at timestamptz )\nCREATE 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 )\nCREATE TABLE gaming_technology.achievements (\n    achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an achievement definition\n    game_id uuid NOT NULL, -- FK linking to the game the achievement belongs to\n    name character varying(150) NOT NULL, -- name of the achievement\n    description text NOT NULL, -- how to unlock the achievement\n    icon_url character varying(255), -- URL for the achievement's icon\n    points integer DEFAULT 0, -- points awarded for unlocking (optional)\n    hidden boolean DEFAULT false, -- whether the achievement details are hidden until unlocked\n    PRIMARY KEY (achievement_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.player_inventory (\n    inventory_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an inventory entry\n    player_id uuid NOT NULL, -- FK linking to the player owning the item\n    item_id uuid NOT NULL, -- FK linking to the item definition\n    quantity integer NOT NULL DEFAULT 1, -- number of items held (for stackable items)\n    acquired_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the item was acquired\n    instance_data jsonb, -- data specific to this instance (e.g., weapon mods, durability)\n    PRIMARY KEY (inventory_id),\n    -- Optional unique constraint if items are non-stackable or unique instances\n    -- UNIQUE (player_id, item_id) -- Use if quantity is always 1\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (item_id) REFERENCES gaming_technology.in_game_items(item_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all claim documents along with the beneficiary first and last names and their relationship for policies where a document of type 'MEDICAL_REPORT' exists."}, {"role": "assistant", "content": "SELECT cd.document_id, cd.claim_id, cd.file_name, cd.document_type, pb.first_name, pb.last_name, pb.relationship\nFROM insurance.claim_documents cd\nINNER JOIN insurance.policy_beneficiaries pb ON cd.claim_id = pb.policy_id\nWHERE cd.document_type = 'MEDICAL_REPORT';"}, {"role": "user", "content": "Actually, please include only beneficiaries whose percentage_share is 30% or more."}, {"role": "assistant", "content": "SELECT cd.document_id, cd.claim_id, cd.file_name, cd.document_type, pb.first_name, pb.last_name, pb.relationship, pb.percentage_share\nFROM insurance.claim_documents cd\nINNER JOIN insurance.policy_beneficiaries pb ON cd.claim_id = pb.policy_id\nWHERE cd.document_type = 'MEDICAL_REPORT'\n  AND pb.percentage_share >= 30;"}, {"role": "user", "content": "Also, add the uploaded_at timestamp from the document to the results and order by uploaded_at descending."}, {"role": "assistant", "content": "SELECT cd.document_id, cd.claim_id, cd.file_name, cd.document_type, cd.uploaded_at, pb.first_name, pb.last_name, pb.relationship, pb.percentage_share\nFROM insurance.claim_documents cd\nINNER JOIN insurance.policy_beneficiaries pb ON cd.claim_id = pb.policy_id\nWHERE cd.document_type = 'MEDICAL_REPORT'\n  AND pb.percentage_share >= 30\nORDER BY cd.uploaded_at DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.insurance_products ( product_id.text, 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 )\nCREATE 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 )\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "List the first name, last name, license number, and status for all drivers whose license expires in the next 6 months."}, {"role": "assistant", "content": "SELECT\n  first_name,\n  last_name,\n  license_number,\n  status\nFROM transportation.drivers\nWHERE\n  license_expiry_date BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '6 month'\nORDER BY\n  license_expiry_date;"}, {"role": "user", "content": "Now, count how many drivers from that list have an 'Active' status."}, {"role": "assistant", "content": "SELECT\n  COUNT(*)\nFROM transportation.drivers\nWHERE\n  license_expiry_date BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '6 month' AND status = 'Active';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List each citizen's first and last name alongside the first and last name of another citizen born in the same year but with a different national ID number."}, {"role": "assistant", "content": "SELECT c1.first_name  AS first_name_1,\n       c1.last_name   AS last_name_1,\n       c2.first_name  AS first_name_2,\n       c2.last_name   AS last_name_2,\n       EXTRACT(YEAR FROM c1.date_of_birth) AS birth_year\nFROM government_services.citizens c1\nJOIN government_services.citizens c2\n  ON EXTRACT(YEAR FROM c1.date_of_birth) = EXTRACT(YEAR FROM c2.date_of_birth)\n AND c1.national_id_number <> c2.national_id_number\n AND c1.citizen_id < c2.citizen_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all Sui NFT collections where the owner is not null, including their name and collection_type."}, {"role": "assistant", "content": "SELECT name, collection_type FROM sui_nfts WHERE owner IS NOT NULL;"}, {"role": "user", "content": "Can you also include the display field and filter to only show collections with a package_id starting with '0x'?"}, {"role": "assistant", "content": "SELECT name, collection_type, display FROM sui_nfts WHERE owner IS NOT NULL AND package_id LIKE '0x%';"}, {"role": "user", "content": "Now sort these results by name in ascending order and limit to 10."}, {"role": "assistant", "content": "SELECT name, collection_type, display FROM sui_nfts WHERE owner IS NOT NULL AND package_id LIKE '0x%' ORDER BY name ASC LIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE token_metas ( block_timestamp timestamp(6) NOT NULL, block_number bigint NOT NULL, transaction_hash varchar NOT NULL, transaction_index bigint NOT NULL, from_address varchar NOT NULL, contract_address varchar NOT NULL, symbol varchar NOT NULL, total_supply varchar NOT NULL, name varchar NOT NULL, decimals bigint NOT NULL, is_erc20 integer NOT NULL, is_erc721 integer NOT NULL, is_erc1155 integer NOT NULL, is_proxy integer NOT NULL, extra_info varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE erc20_balances ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk varchar )\nCREATE TABLE nft_holder_historical ( block_number.bigint, contract_address.text, wallet_address.text, token_id.text, contract_type.text, amount.text, pk.integer )\nCREATE TABLE sui_coins_metadata ( object_id varchar NOT NULL, coin_type varchar NOT NULL, status varchar NOT NULL, decimals bigint NOT NULL, description varchar NOT NULL, icon_url varchar NOT NULL, symbol varchar NOT NULL, name varchar NOT NULL )\nCREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )\nCREATE 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 )\nCREATE TABLE token_prices_latest (\n    blockchain varchar(36) NOT NULL, -- blockchain fields for the functionType  in contract\n    address varchar(42) NOT NULL, -- address fields for the functionType  in contract\n    decimals bigint NOT NULL, -- decimals fields for the functionType  in contract\n    symbol varchar(36) NOT NULL, -- symbol fields for the functionType  in contract\n    price real NOT NULL, -- price fields for the functionType  in contract\n    timestamp timestamp(6) NOT NULL  -- timestamp fields for the functionType  in contract\n)\nCREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )\nCREATE 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 )\nCREATE TABLE token_balances_bitcoin (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar(255) NOT NULL, -- Ticker: Identifier of the inscription\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply varchar NOT NULL, -- Max supply: Set max supply of the inscription\n    amount varchar NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE TABLE token_info_bitcoin (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    tick varchar(255) NOT NULL, -- Ticker:  Identifier of the inscription\n    max_supply decimal(38,0) NOT NULL, -- Max supply: Set max supply of the inscription\n    lim decimal(38,0) NOT NULL, -- Mint limit: limit per inscription\n    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint\n    dec integer NOT NULL, -- Decimal for minimum divie\n    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)\n)\nCREATE TABLE token_activities_bitcoin (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    log_index integer NOT NULL, -- Index of the log within the transaction\n    type varchar(20) NOT NULL, -- Operation: Type of event (deploy, mint, transfer, list)\n    tick varchar(255) NOT NULL, -- Ticker: Identifier of the inscription\n    id varchar(255) NOT NULL, -- Unique identifier of the inscription\n    amt decimal(38,0) NOT NULL, -- Amount to mint: States the amount of the inscription to operation. When operation is mint, has to be less or equal to \"lim\"\n    from_address varchar(62) NOT NULL, -- Address sending the inscription\n    to_address varchar(62) NOT NULL  -- Address receiving the inscription\n)\nCREATE TABLE token_balances_avalanche (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar(20) NOT NULL, -- Ticker: Identifier of the inscription\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply decimal(38,0) NOT NULL, -- Max supply: Set max supply of the inscription\n    amount decimal(38,0) NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE TABLE token_info_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar(20) NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL, minted decimal(38,0) NOT NULL, holders decimal(38,0) NOT NULL, txs decimal(38,0) NOT NULL, updated_timestamp timestamp(3) NOT NULL, completed_timestamp timestamp(3) NOT NULL, id varchar(255) NOT NULL )\n"}
{"conversations": [{"role": "user", "content": "I need a list of claim_ids that have at least one document of type 'Photo' and at least one of type 'Invoice'."}, {"role": "assistant", "content": "SELECT DISTINCT cd.claim_id\nFROM insurance.claim_documents cd\nWHERE cd.document_type IN ('Photo', 'Invoice');"}, {"role": "user", "content": "It returns claim_ids that have either a Photo or an Invoice but not necessarily both. I need only those with both types."}, {"role": "assistant", "content": "SELECT cd.claim_id\nFROM insurance.claim_documents cd\nWHERE cd.document_type IN ('Photo', 'Invoice')\nGROUP BY cd.claim_id\nHAVING COUNT(DISTINCT cd.document_type) = 2;"}, {"role": "user", "content": "Actually, I only want those documents uploaded in 2024."}, {"role": "assistant", "content": "SELECT cd.claim_id\nFROM insurance.claim_documents cd\nWHERE cd.document_type IN ('Photo', 'Invoice')\n  AND cd.uploaded_at >= '2024-01-01'\nGROUP BY cd.claim_id\nHAVING COUNT(DISTINCT cd.document_type) = 2;"}, {"role": "user", "content": "Also, I'd like to see the policy_number and incident_date for these claims."}, {"role": "assistant", "content": "SELECT c.claim_id, p.policy_number, c.incident_date\nFROM (\n  SELECT cd.claim_id\n  FROM insurance.claim_documents cd\n  WHERE cd.document_type IN ('Photo', 'Invoice')\n    AND cd.uploaded_at >= '2024-01-01'\n  GROUP BY cd.claim_id\n  HAVING COUNT(DISTINCT cd.document_type) = 2\n) AS filtered\nJOIN insurance.claims c ON filtered.claim_id = c.claim_id\nJOIN insurance.policies p ON c.policy_id = p.policy_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.customers (\n    customer_id character varying(64) NOT NULL,  -- unique identifier for the customer\n    first_name character varying(100) NOT NULL, -- customer's first name\n    last_name character varying(100) NOT NULL, -- customer's last name\n    date_of_birth date NOT NULL, -- customer's date of birth\n    ssn_hash character varying(128), -- Hashed social security number (or national ID)\n    address_line1 character varying(255) NOT NULL,\n    address_line2 character varying(255),\n    city character varying(100) NOT NULL,\n    state character varying(50) NOT NULL,\n    zip_code character varying(20) NOT NULL,\n    country character varying(50) NOT NULL DEFAULT 'USA',\n    phone_number character varying(30),\n    email character varying(128) UNIQUE, -- unique email address\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the customer record was created\n    updated_at timestamp, -- when the customer record was last updated\n    status character varying(20) NOT NULL DEFAULT 'Active', -- e.g., Active, Inactive, Prospect\n    PRIMARY KEY (customer_id)\n)\nCREATE TABLE insurance.policies (\n    policy_id character varying(64) NOT NULL, -- unique identifier for the policy\n    customer_id character varying(64) NOT NULL, -- identifier for the policyholder (FK to customers)\n    product_id character varying(64) NOT NULL, -- identifier for the insurance product (FK to insurance_products)\n    agent_id character varying(64), -- identifier for the agent who sold the policy (FK to agents)\n    policy_number character varying(100) NOT NULL UNIQUE, -- customer-facing policy number\n    start_date date NOT NULL, -- date the policy coverage begins\n    end_date date NOT NULL, -- date the policy coverage ends\n    premium_amount numeric(12, 2) NOT NULL, -- total premium for the policy term\n    coverage_limit numeric(15, 2) NOT NULL, -- maximum amount covered\n    deductible numeric(10, 2) NOT NULL, -- amount customer pays before coverage kicks in\n    status character varying(30) NOT NULL, -- e.g., Active, Expired, Cancelled, Pending\n    issued_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the policy was issued\n    cancellation_date date,\n    cancellation_reason text,\n    PRIMARY KEY (policy_id)\n)\nCREATE TABLE insurance.claims (\n    claim_id character varying(64) NOT NULL, -- unique identifier for the claim\n    policy_id character varying(64) NOT NULL, -- identifier of the policy under which the claim is made (FK to policies)\n    customer_id character varying(64) NOT NULL, -- identifier of the customer making the claim (FK to customers)\n    incident_date timestamp NOT NULL, -- date and time of the incident leading to the claim\n    reported_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the claim was reported\n    description text NOT NULL, -- detailed description of the incident and claim\n    estimated_loss numeric(15, 2), -- initial estimated cost of the loss\n    status character varying(30) NOT NULL, -- e.g., Filed, Processing, Under Review, Approved, Denied, Settled\n    settlement_amount numeric(15, 2), -- final amount paid out\n    settlement_date date,\n    claim_handler_id character varying(64), -- identifier for the employee handling the claim (FK to employees/adjusters)\n    police_report_number character varying(100),\n    PRIMARY KEY (claim_id)\n)\nCREATE TABLE insurance.insurance_products (\n    product_id character varying(64) NOT NULL, -- unique identifier for the insurance product\n    product_name character varying(150) NOT NULL, -- name of the insurance product (e.g., 'Comprehensive Auto Insurance')\n    product_type character varying(50) NOT NULL, -- category like 'Auto', 'Home', 'Life', 'Health', 'Travel'\n    description text, -- detailed description of the product\n    base_premium numeric(10, 2) NOT NULL, -- starting premium before adjustments\n    coverage_details text, -- details about what is covered (could be JSON or structured text)\n    underwriting_rules text, -- rules used for assessing risk and eligibility\n    is_active boolean NOT NULL DEFAULT true, -- whether the product is currently offered\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,\n    updated_at timestamp,\n    PRIMARY KEY (product_id)\n)\nCREATE TABLE insurance.agents (\n    agent_id character varying(64) NOT NULL, -- unique identifier for the agent\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    agency_name character varying(150),\n    license_number character varying(100) NOT NULL UNIQUE, -- state insurance license number\n    license_state character varying(50) NOT NULL,\n    contact_email character varying(128) UNIQUE,\n    contact_phone character varying(30),\n    hire_date date,\n    termination_date date,\n    status character varying(20) NOT NULL DEFAULT 'Active', -- e.g., Active, Terminated, On Leave\n    commission_rate numeric(5, 4) NOT NULL DEFAULT 0.05, -- percentage commission\n    manager_id character varying(64), -- identifier for the agent's manager (FK to agents or employees)\n    PRIMARY KEY (agent_id)\n)\nCREATE TABLE insurance.claim_documents (\n    document_id character varying(64) NOT NULL, -- unique identifier for the document\n    claim_id character varying(64) NOT NULL, -- identifier of the claim this document relates to (FK to claims)\n    document_type character varying(50) NOT NULL, -- e.g., Police Report, Photo, Invoice, Medical Bill\n    file_name character varying(255) NOT NULL, -- original name of the uploaded file\n    file_path character varying(512) NOT NULL, -- storage path (e.g., S3 URL, network path)\n    file_size_bytes integer, -- size of the file in bytes\n    mime_type character varying(100), -- MIME type of the file (e.g., 'image/jpeg', 'application/pdf')\n    uploaded_by character varying(64), -- identifier of the user/system who uploaded (FK to users/customers)\n    uploaded_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- time of upload\n    description text, -- optional description of the document\n    PRIMARY KEY (document_id)\n)\nCREATE TABLE insurance.policy_beneficiaries (\n    beneficiary_id character varying(64) NOT NULL, -- unique identifier for the beneficiary entry\n    policy_id character varying(64) NOT NULL, -- identifier of the life/relevant policy (FK to policies)\n    customer_id character varying(64) NOT NULL, -- identifier of the beneficiary (could be FK to customers or store info directly)\n    first_name character varying(100) NOT NULL, -- beneficiary first name (if not linking to customers table)\n    last_name character varying(100) NOT NULL, -- beneficiary last name\n    relationship character varying(50) NOT NULL, -- relationship to the policyholder (e.g., Spouse, Child, Parent)\n    percentage_share numeric(5, 2) NOT NULL CHECK (percentage_share > 0 AND percentage_share <= 100), -- percentage of payout\n    contact_info text, -- contact details for the beneficiary\n    added_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,\n    PRIMARY KEY (beneficiary_id),\n    UNIQUE (policy_id, customer_id) -- Ensure a person is listed only once per policy\n)\n"}
{"conversations": [{"role": "user", "content": "List all replacement policies where a customer received a new policy starting the day after their previous policy was cancelled. Return customer_id, original_policy_id, original_cancellation_date, new_policy_id, new_start_date."}, {"role": "assistant", "content": "SELECT orig.customer_id,\n       orig.policy_id      AS original_policy_id,\n       orig.cancellation_date AS original_cancellation_date,\n       nw.policy_id        AS new_policy_id,\n       nw.start_date       AS new_start_date\nFROM insurance.policies orig\nJOIN insurance.policies nw\n  ON orig.customer_id = nw.customer_id\n AND orig.cancellation_date IS NOT NULL\n AND nw.start_date = orig.cancellation_date + INTERVAL '1 day';"}, {"role": "user", "content": "Now include the premium_amount difference as premium_diff and only show cases where the new policy's premium is higher."}, {"role": "assistant", "content": "SELECT orig.customer_id,\n       orig.policy_id      AS original_policy_id,\n       orig.cancellation_date AS original_cancellation_date,\n       nw.policy_id        AS new_policy_id,\n       nw.start_date       AS new_start_date,\n       (nw.premium_amount - orig.premium_amount) AS premium_diff\nFROM insurance.policies orig\nJOIN insurance.policies nw\n  ON orig.customer_id = nw.customer_id\n AND orig.cancellation_date IS NOT NULL\n AND nw.start_date = orig.cancellation_date + INTERVAL '1 day'\nWHERE nw.premium_amount > orig.premium_amount;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "Find all wallet addresses that don't have an associated user_id."}, {"role": "assistant", "content": "SELECT address_id FROM blockchain.wallets WHERE user_id IS NULL;"}, {"role": "user", "content": "Now show me these addresses along with their private_key, and join with another table to see if they have any transactions."}, {"role": "assistant", "content": "SELECT w.address_id, w.private_key FROM blockchain.wallets w WHERE w.user_id IS NULL;"}, {"role": "user", "content": "Actually, I want to see the count of such wallet addresses grouped by the first 3 characters of their address_id."}, {"role": "assistant", "content": "SELECT SUBSTRING(address_id, 1, 3) as address_prefix, COUNT(*) as address_count FROM blockchain.wallets WHERE user_id IS NULL GROUP BY SUBSTRING(address_id, 1, 3);"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE blockchain.wallets ( wallet_id.text, user_id.text, address_id.text, private_key.text )\n"}
{"conversations": [{"role": "user", "content": "For each premium payment, list all previous payments made by the same customer. Show customer_id, previous_payment_id, previous_payment_date, current_payment_id, current_payment_date, and amount difference."}, {"role": "assistant", "content": "SELECT p1.customer_id,\n       p1.payment_id AS previous_payment_id,\n       p1.payment_date AS previous_payment_date,\n       p2.payment_id AS current_payment_id,\n       p2.payment_date AS current_payment_date,\n       p2.amount_paid - p1.amount_paid AS amount_diff\nFROM insurance.premium_payments p1\nJOIN insurance.premium_payments p2\n  ON p1.customer_id = p2.customer_id\n  AND p1.payment_date < p2.payment_date;"}, {"role": "user", "content": "Actually, only include pairs where the current payment date is in 2024."}, {"role": "assistant", "content": "SELECT p1.customer_id,\n       p1.payment_id AS previous_payment_id,\n       p1.payment_date AS previous_payment_date,\n       p2.payment_id AS current_payment_id,\n       p2.payment_date AS current_payment_date,\n       p2.amount_paid - p1.amount_paid AS amount_diff\nFROM insurance.premium_payments p1\nJOIN insurance.premium_payments p2\n  ON p1.customer_id = p2.customer_id\n  AND p1.payment_date < p2.payment_date\nWHERE p2.payment_date BETWEEN '2024-01-01' AND '2024-12-31';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "I need the average capacity of vehicles for each fuel_type."}, {"role": "assistant", "content": "SELECT fuel_type,\n       AVG(capacity) AS avg_capacity\nFROM transportation.vehicles\nGROUP BY fuel_type;"}, {"role": "user", "content": "Only include fuel types where the vehicle count is at least 10."}, {"role": "assistant", "content": "SELECT fuel_type,\n       AVG(capacity) AS avg_capacity\nFROM transportation.vehicles\nGROUP BY fuel_type\nHAVING COUNT(*) >= 10;"}, {"role": "user", "content": "Also show the number of vehicles for each of these fuel types."}, {"role": "assistant", "content": "SELECT fuel_type,\n       COUNT(*) AS vehicle_count,\n       AVG(capacity) AS avg_capacity\nFROM transportation.vehicles\nGROUP BY fuel_type\nHAVING COUNT(*) >= 10;"}, {"role": "user", "content": "Please round avg_capacity to one decimal place."}, {"role": "assistant", "content": "SELECT fuel_type,\n       COUNT(*) AS vehicle_count,\n       ROUND(AVG(capacity)::numeric, 1) AS avg_capacity\nFROM transportation.vehicles\nGROUP BY fuel_type\nHAVING COUNT(*) >= 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.vehicles ( vehicle_id.text, license_plate.text, vin.text, make.text, model.text, year.integer, type.text, capacity.integer, fuel_type.text, status.text, depot_id.text, acquisition_date.date )\n"}
{"conversations": [{"role": "user", "content": "Show the IDs and registration dates of all verified citizens who could be eligible for at least one active service. Display the citizen ID and registration date."}, {"role": "assistant", "content": "SELECT DISTINCT c.citizen_id, c.registration_date\nFROM government_services.citizens c\nJOIN government_services.services s ON s.is_active = true\nWHERE c.is_verified = true;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id character varying(64) NOT NULL, national_id_number character varying(128) NOT NULL UNIQUE, 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, contact_email character varying(128) UNIQUE, contact_phone character varying(32), registration_date timestamp NOT NULL, is_verified boolean DEFAULT false, PRIMARY KEY (citizen_id) )\nCREATE TABLE government_services.services ( service_id.text, agency_id.text, service_name.text, description.text, category.text, eligibility_criteria.text, standard_fee.numeric, average_processing_time_days.integer, is_active.boolean, online_application_url.text )\n"}
{"conversations": [{"role": "user", "content": "Show me all rooms along with their current overall review rating for each room, including the room number and property id."}, {"role": "assistant", "content": "SELECT r.room_number, r.property_id, AVG(rv.rating_overall) AS average_overall_rating\nFROM hospitality_technology.rooms r\nLEFT JOIN hospitality_technology.reviews rv\n  ON r.property_id = rv.property_id\nGROUP BY r.room_number, r.property_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.rooms ( room_id.text, property_id.text, room_number.text, room_type_id.text, floor.integer, status.text, is_smoking.boolean, features.text, current_condition.text, last_cleaned_at.timestamp )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Provide a list of all log entries recorded since the start of 2024, including the user ID, action, and the exact time the log occurred."}, {"role": "assistant", "content": "SELECT user_id, action, logged_at FROM logs WHERE logged_at >= '2024-01-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.wallets ( wallet_id.text, user_id.text, address.text, private_key.text, created_at.timestamp )\nCREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )\nCREATE TABLE trading_platform.logs ( log_id.text, user_id.text, action.text, details.text, logged_at.timestamp )\nCREATE TABLE trading_platform.notifications ( notification_id.text, user_id.text, message.text, sent_at.timestamp, read_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "For all NFT collections on the Ethereum blockchain, show me the collection name and the current floor price. Sort by floor price descending."}, {"role": "assistant", "content": "SELECT name, floor_price FROM nft_collections WHERE blockchain = 'Ethereum' ORDER BY CAST(floor_price AS FLOAT) DESC;"}, {"role": "user", "content": "Include also the collection symbol and the number of tokens in each collection."}, {"role": "assistant", "content": "SELECT name, symbol, floor_price, token_count FROM nft_collections WHERE blockchain = 'Ethereum' ORDER BY CAST(floor_price AS FLOAT) DESC;"}, {"role": "user", "content": "Can you also show the owner of each collection in the result?"}, {"role": "assistant", "content": "SELECT name, symbol, floor_price, token_count, owner FROM nft_collections WHERE blockchain = 'Ethereum' ORDER BY CAST(floor_price AS FLOAT) DESC;"}, {"role": "user", "content": "Now only include collections whose floor price is greater than 1 ETH."}, {"role": "assistant", "content": "SELECT name, symbol, floor_price, token_count, owner FROM nft_collections WHERE blockchain = 'Ethereum' AND CAST(floor_price AS FLOAT) > 1 AND floor_price_symbol = 'ETH' ORDER BY CAST(floor_price AS FLOAT) DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE token_metas ( block_timestamp timestamp(6) NOT NULL, block_number bigint NOT NULL, transaction_hash varchar NOT NULL, transaction_index bigint NOT NULL, from_address varchar NOT NULL, contract_address varchar NOT NULL, symbol varchar NOT NULL, total_supply varchar NOT NULL, name varchar NOT NULL, decimals bigint NOT NULL, is_erc20 integer NOT NULL, is_erc721 integer NOT NULL, is_erc1155 integer NOT NULL, is_proxy integer NOT NULL, extra_info varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE erc20_balances ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE nft_holder_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_metadata ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, token_id varchar NOT NULL, contract_name varchar NOT NULL, erc_type varchar NOT NULL, amount bigint NOT NULL, minter varchar NOT NULL, owner varchar NOT NULL, mint_block_number bigint NOT NULL, mint_time bigint NOT NULL, mint_transaction_hash varchar NOT NULL, mint_price varchar NOT NULL, token_uri varchar NOT NULL, metadata varchar NOT NULL, name varchar NOT NULL, image_uri varchar NOT NULL, traits varchar NOT NULL, updated_at bigint NOT NULL, status varchar NOT NULL, rarity_score real NOT NULL, rarity_rank integer NOT NULL, unique_attribute_count integer NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_prices ( uuid varchar(36) NOT NULL, blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )\nCREATE TABLE token_prices_latest ( blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )\nCREATE TABLE erc20_approval ( block_number bigint NOT NULL, block_timestamp timestamp(6) NOT NULL, transaction_index integer NOT NULL, transaction_hash varchar NOT NULL, log_index integer NOT NULL, contract_address varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_activities ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar NOT NULL, tick varchar NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(42) NOT NULL, to_address varchar(42) NOT NULL )\nCREATE TABLE mud_holesky_redstone ( address varchar NOT NULL, table_id varchar NOT NULL, key_bytes varchar NOT NULL, key0 varchar NOT NULL, key1 varchar NOT NULL, static_data varchar NOT NULL, encoded_lengths varchar NOT NULL, dynamic_data varchar NOT NULL, is_deleted boolean NOT NULL, block_number bigint NOT NULL, log_index bigint NOT NULL )\nCREATE TABLE token_balances_bitcoin ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar(255) NOT NULL, wallet_address varchar(42) NOT NULL, total_supply varchar NOT NULL, amount varchar NOT NULL )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(62) NOT NULL, to_address varchar(62) NOT NULL )\nCREATE TABLE token_info_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar(20) NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL, minted decimal(38,0) NOT NULL, holders decimal(38,0) NOT NULL, txs decimal(38,0) NOT NULL, updated_timestamp timestamp(3) NOT NULL, completed_timestamp timestamp(3) NOT NULL, id varchar(255) NOT NULL )\n"}
{"conversations": [{"role": "user", "content": "What is the schedule of trains arriving at station with ID 'ST789' tomorrow?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide the train schedule for station ID 'ST789' as this information is not available in the current database. The table only contains details about station attributes such as name, location, and number of platforms. For train schedules, please refer to the relevant train service provider or timetable database."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.stations ( station_id text, station_name text, city text, state_province text, country_code text, address text, timezone text, number_of_platforms integer, created_at timestamp, last_updated_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List each service category and the count of services that are currently available."}, {"role": "assistant", "content": "SELECT category,\n       COUNT(*) AS available_service_count\nFROM hospitality_technology.services\nWHERE is_available = TRUE\nGROUP BY category;"}, {"role": "user", "content": "Only include categories with more than 5 available services and order by available_service_count descending."}, {"role": "assistant", "content": "SELECT category,\n       COUNT(*) AS available_service_count\nFROM hospitality_technology.services\nWHERE is_available = TRUE\nGROUP BY category\nHAVING COUNT(*) > 5\nORDER BY available_service_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties ( property_id character varying(64) NOT NULL, property_name character varying(255) NOT NULL, address_line1 character varying(255) NOT NULL, address_line2 character varying(255), city character varying(100) NOT NULL, state_province character varying(100), postal_code character varying(20) NOT NULL, country_code character varying(3) NOT NULL, phone_number character varying(30), email_address character varying(255), property_type character varying(50) NOT NULL, star_rating numeric(2,1), timezone character varying(64) NOT NULL, manager_staff_id character varying(64), created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (property_id) )\nCREATE TABLE hospitality_technology.room_types ( room_type_id text, property_id text, type_name text, description text, base_rate numeric, max_occupancy integer, bed_type text, area_sqft numeric, amenities text )\nCREATE TABLE hospitality_technology.guests ( guest_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, email character varying(255) UNIQUE, phone_number character varying(30), date_of_birth date, address_line1 character varying(255), city character varying(100), state_province character varying(100), postal_code character varying(20), country_code character varying(3), preferences text, loyalty_member_id character varying(64) UNIQUE, communication_consent boolean DEFAULT true, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (guest_id) )\nCREATE TABLE hospitality_technology.reservations (\n    reservation_id character varying(64) NOT NULL,  -- unique identifier for the booking\n    property_id character varying(64) NOT NULL, -- FK to properties table\n    guest_id character varying(64) NOT NULL, -- FK to guests table (primary guest)\n    room_id character varying(64), -- FK to rooms table (assigned room, might be null initially)\n    room_type_id character varying(64) NOT NULL, -- FK to room_types table (booked room type)\n    check_in_date date NOT NULL, -- scheduled check-in date\n    check_out_date date NOT NULL, -- scheduled check-out date\n    actual_check_in_ts timestamp with time zone, -- actual check-in time\n    actual_check_out_ts timestamp with time zone, -- actual check-out time\n    num_adults integer NOT NULL, -- number of adults\n    num_children integer DEFAULT 0, -- number of children\n    status character varying(50) NOT NULL, -- e.g., Pending, Confirmed, CheckedIn, CheckedOut, Cancelled, NoShow\n    booking_source character varying(100), -- e.g., Website, OTA (Expedia, Booking.com), Phone, WalkIn\n    rate_plan_id character varying(64), -- FK to rate_plans table (optional)\n    total_amount numeric(12, 2), -- estimated or final total cost\n    amount_paid numeric(12, 2) DEFAULT 0.00, -- amount already paid\n    special_requests text, -- specific guest requests for this booking\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (reservation_id),\n    FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id),\n    FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id),\n    FOREIGN KEY (room_id) REFERENCES hospitality_technology.rooms(room_id),\n    FOREIGN KEY (room_type_id) REFERENCES hospitality_technology.room_types(room_type_id)\n)\nCREATE TABLE hospitality_technology.services ( service_id.text, property_id.text, service_name.text, description.text, category.text, price.numeric, unit.text, is_available.boolean, department.text )\nCREATE TABLE hospitality_technology.service_orders ( order_id character varying(64) NOT NULL, reservation_id character varying(64), guest_id character varying(64) NOT NULL, service_id character varying(64) NOT NULL, staff_id_ordered character varying(64), staff_id_delivered character varying(64), order_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, delivery_timestamp timestamp with time zone, quantity integer NOT NULL DEFAULT 1, unit_price numeric(10, 2) NOT NULL, total_price numeric(12, 2) NOT NULL, status character varying(50) NOT NULL, notes text, bill_id character varying(64), PRIMARY KEY (order_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (service_id) REFERENCES hospitality_technology.services(service_id), FOREIGN KEY (staff_id_ordered) REFERENCES hospitality_technology.staff(staff_id), FOREIGN KEY (staff_id_delivered) REFERENCES hospitality_technology.staff(staff_id) )\n"}
{"conversations": [{"role": "user", "content": "Provide each pair of plans that share the same plan_type but are offered by different providers."}, {"role": "assistant", "content": "SELECT p1.plan_type,\n       p1.plan_id AS plan1_id,\n       p1.plan_name AS plan1_name,\n       p1.insurance_provider AS provider1,\n       p2.plan_id AS plan2_id,\n       p2.plan_name AS plan2_name,\n       p2.insurance_provider AS provider2\nFROM healthcare.insurance_plans p1\nJOIN healthcare.insurance_plans p2\n  ON p1.plan_type = p2.plan_type\n AND p1.insurance_provider < p2.insurance_provider;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.insurance_plans ( plan_id text PRIMARY KEY, plan_name text, insurance_provider text, plan_type text, contact_phone text, website text )\n"}
{"conversations": [{"role": "user", "content": "What is the average number of wallets each user owns?"}, {"role": "assistant", "content": "SELECT\n  AVG(wallet_count) AS avg_wallets_per_user\nFROM (\n  SELECT user_id, COUNT(*) AS wallet_count\n  FROM web3.wallets\n  GROUP BY user_id\n) AS sub;"}, {"role": "user", "content": "Actually, calculate the average only for users who own more than one wallet."}, {"role": "assistant", "content": "SELECT\n  AVG(wallet_count) AS avg_wallets_per_user\nFROM (\n  SELECT user_id, COUNT(*) AS wallet_count\n  FROM web3.wallets\n  GROUP BY user_id\n  HAVING COUNT(*) > 1\n) AS sub;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.wallets ( wallet_id text PRIMARY KEY, user_id text, address text, private_key text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "What is the reason behind the cost variation for maintenance of asset_id 'ASSET456' over the past year?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information on the reasons behind cost variations for maintenance. The data in the maintenance_records table includes only the cost amount and other basic details of each maintenance record, but it does not contain explanations or factors influencing cost changes."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.maintenance_records ( record_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, asset_type character varying(32) NOT NULL, maintenance_type character varying(128) NOT NULL, staff_id character varying(64), start_datetime timestamp NOT NULL, end_datetime timestamp, description text NOT NULL, cost numeric(12, 2), status character varying(32) NOT NULL DEFAULT 'Completed', PRIMARY KEY (record_id), FOREIGN KEY (staff_id) REFERENCES train_station_management.staff(staff_id) )\n"}
{"conversations": [{"role": "user", "content": "Find all smart contracts where the code length is greater than 1000 characters."}, {"role": "assistant", "content": "SELECT contract_id, creator_address, timestamp FROM blockchain.smart_contracts WHERE LENGTH(code) > 1000;"}, {"role": "user", "content": "Now group these by creator_address and show the count of such contracts per creator."}, {"role": "assistant", "content": "SELECT creator_address, COUNT(*) AS long_code_contracts FROM blockchain.smart_contracts WHERE LENGTH(code) > 1000 GROUP BY creator_address;"}, {"role": "user", "content": "Can you order the results by the count in descending order?"}, {"role": "assistant", "content": "SELECT creator_address, COUNT(*) AS long_code_contracts FROM blockchain.smart_contracts WHERE LENGTH(code) > 1000 GROUP BY creator_address ORDER BY long_code_contracts DESC;"}, {"role": "user", "content": "Now show only creators who have more than 3 such contracts."}, {"role": "assistant", "content": "SELECT creator_address, COUNT(*) AS long_code_contracts FROM blockchain.smart_contracts WHERE LENGTH(code) > 1000 GROUP BY creator_address HAVING COUNT(*) > 3 ORDER BY long_code_contracts DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE blockchain.smart_contracts ( contract_id text PRIMARY KEY, creator_address text, code text, timestamp timestamp )\n"}
{"conversations": [{"role": "user", "content": "Find all medical records where the treatment plan includes 'physical therapy' and the patient has an active primary insurance plan, showing the patient ID, record date, and insurance provider details."}, {"role": "assistant", "content": "SELECT mr.patient_id, mr.record_date, ip.insurance_provider, ip.plan_name, pi.policy_number FROM healthcare.medical_records mr JOIN healthcare.patients p ON mr.patient_id = p.patient_id JOIN healthcare.patient_insurance pi ON p.patient_id = pi.patient_id AND pi.is_primary = true JOIN healthcare.insurance_plans ip ON pi.plan_id = ip.plan_id WHERE mr.treatment_plan LIKE '%physical therapy%' AND (pi.expiration_date IS NULL OR pi.expiration_date > CURRENT_DATE);"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.patients ( patient_id text, 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 )\nCREATE TABLE healthcare.appointments ( appointment_id text, patient_id text, doctor_id text, appointment_time timestamp, duration_minutes integer, reason text, status text, location_id text, notes text, created_at timestamp )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE healthcare.medications ( medication_id text, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )\nCREATE TABLE healthcare.insurance_plans (\n    plan_id character varying(64) NOT NULL, -- unique identifier for the insurance plan\n    plan_name character varying(200) NOT NULL, -- name of the insurance plan\n    insurance_provider character varying(100) NOT NULL, -- name of the insurance company\n    plan_type character varying(50), -- e.g., PPO, HMO, EPO\n    contact_phone character varying(20), -- provider contact number\n    website character varying(255), -- provider website\n    PRIMARY KEY (plan_id)\n)\nCREATE TABLE healthcare.patient_insurance ( patient_insurance_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, plan_id character varying(64) NOT NULL, policy_number character varying(100) NOT NULL, group_number character varying(100), subscriber_name character varying(200), effective_date date NOT NULL, expiration_date date, is_primary boolean NOT NULL DEFAULT true, PRIMARY KEY (patient_insurance_id), UNIQUE (patient_id, plan_id, policy_number) )\n"}
{"conversations": [{"role": "user", "content": "What is the total estimated loss for all claims reported in the year 2024?"}, {"role": "assistant", "content": "SELECT SUM(estimated_loss) FROM insurance.claims WHERE EXTRACT(YEAR FROM reported_date) = 2024;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List the full name (first name and last name) of all citizens who have uploaded documents whose expiry date is in the past."}, {"role": "assistant", "content": "SELECT DISTINCT T1.first_name, T1.last_name FROM government_services.citizens AS T1 INNER JOIN government_services.documents AS T2 ON T1.citizen_id = T2.citizen_id WHERE T2.expiry_date < CURRENT_DATE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id text PRIMARY KEY, 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me the top 5 users with the most wallet addresses, along with the count of their wallets."}, {"role": "assistant", "content": "SELECT user_id, COUNT(wallet_id) AS wallet_count FROM blockchain.wallets WHERE user_id IS NOT NULL GROUP BY user_id ORDER BY wallet_count DESC LIMIT 5;"}, {"role": "user", "content": "Now include the earliest created wallet address for each of these top 5 users."}, {"role": "assistant", "content": "Note: The wallets table doesn't have a creation timestamp column. Without this information, we cannot determine the earliest created wallet. Please provide a table with creation timestamps if you need this analysis."}, {"role": "user", "content": "Then just show me these top 5 users with their wallet counts and the first wallet_id alphabetically for each user."}, {"role": "assistant", "content": "SELECT user_id, COUNT(wallet_id) AS wallet_count, MIN(wallet_id) AS first_wallet_id FROM blockchain.wallets WHERE user_id IS NOT NULL GROUP BY user_id ORDER BY wallet_count DESC LIMIT 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE blockchain.wallets ( wallet_id text, user_id text, address_id text, private_key text )\n"}
{"conversations": [{"role": "user", "content": "List the first name and last name of employees who have verified documents, along with the document type they verified and the verification status."}, {"role": "assistant", "content": "SELECT e.first_name, e.last_name, d.document_type, d.verification_status FROM government_services.employees AS e JOIN government_services.documents AS d ON e.employee_id = d.verified_by_employee_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE government_services.employees ( employee_id text, agency_id text, first_name text, last_name text, job_title text, department text, work_email text, work_phone text, hire_date date, termination_date date, access_level text, manager_employee_id text )\nCREATE TABLE government_services.appointments ( appointment_id.text, citizen_id.text, employee_id.text, location_id.text, service_id.text, scheduled_start_time.timestamp, scheduled_end_time.timestamp, purpose.text, status.text, booking_method.text, created_at.timestamp, notes.text )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me all insurance plans that cover more than 10 patients as their primary insurance, along with the provider name and contact information."}, {"role": "assistant", "content": "SELECT ip.plan_name, ip.insurance_provider, ip.contact_phone, ip.website, COUNT(pi.patient_id) AS patient_count FROM healthcare.insurance_plans ip JOIN healthcare.patient_insurance pi ON ip.plan_id = pi.plan_id WHERE pi.is_primary = true GROUP BY ip.plan_id HAVING COUNT(pi.patient_id) > 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.patients (\n    patient_id character varying(64) NOT NULL,  -- unique identifier for the patient\n    first_name character varying(100) NOT NULL, -- patient's first name\n    last_name character varying(100) NOT NULL, -- patient's last name\n    date_of_birth date NOT NULL, -- patient's date of birth\n    gender character varying(10), -- patient's gender (e.g., Male, Female, Other)\n    address text, -- patient's home address\n    phone_number character varying(20), -- patient's phone number\n    email character varying(128) UNIQUE, -- patient's email address\n    emergency_contact_name character varying(200), -- name of emergency contact\n    emergency_contact_phone character varying(20), -- phone number of emergency contact\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record creation time\n    updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record last update time\n    PRIMARY KEY (patient_id)\n)\nCREATE TABLE healthcare.doctors (\n    doctor_id character varying(64) NOT NULL,  -- unique identifier for the doctor\n    first_name character varying(100) NOT NULL, -- doctor's first name\n    last_name character varying(100) NOT NULL, -- doctor's last name\n    specialty character varying(100) NOT NULL, -- doctor's medical specialty\n    license_number character varying(50) UNIQUE NOT NULL, -- doctor's medical license number\n    phone_number character varying(20), -- doctor's contact phone\n    email character varying(128) UNIQUE, -- doctor's contact email\n    hospital_affiliation_id character varying(64), -- FK to hospitals table (optional)\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (doctor_id)\n)\nCREATE TABLE healthcare.appointments (\n    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    doctor_id character varying(64) NOT NULL, -- FK to doctors table\n    appointment_time timestamp with time zone NOT NULL, -- date and time of the appointment\n    duration_minutes integer NOT NULL, -- expected duration in minutes\n    reason text, -- reason for the visit\n    status character varying(32) NOT NULL, -- e.g., Scheduled, Completed, Cancelled, No-show\n    location_id character varying(64), -- FK to a potential locations/clinics table\n    notes text, -- notes related to scheduling\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (appointment_id)\n)\nCREATE TABLE healthcare.diagnoses (\n    diagnosis_id character varying(64) NOT NULL, -- unique identifier for the diagnosis entry\n    record_id character varying(64) NOT NULL, -- FK linking to the specific medical record entry\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    doctor_id character varying(64) NOT NULL, -- FK to doctors table (diagnosing doctor)\n    diagnosis_code character varying(20) NOT NULL, -- standard code (e.g., ICD-10)\n    code_type character varying(10) NOT NULL DEFAULT 'ICD-10', -- type of code used\n    description text, -- textual description of the diagnosis\n    diagnosis_date date NOT NULL, -- date the diagnosis was made\n    status character varying(32) NOT NULL, -- e.g., Active, Resolved, Ruled Out\n    is_chronic boolean DEFAULT false, -- flag for chronic conditions\n    PRIMARY KEY (diagnosis_id)\n)\nCREATE TABLE healthcare.medications (\n    medication_id character varying(64) NOT NULL, -- unique identifier for the medication type\n    medication_name character varying(255) NOT NULL, -- common or brand name\n    generic_name character varying(255), -- generic chemical name\n    manufacturer character varying(100), -- drug manufacturer\n    ndc_code character varying(20) UNIQUE, -- National Drug Code (optional but useful)\n    description text, -- description of the medication\n    PRIMARY KEY (medication_id)\n)\nCREATE TABLE healthcare.prescriptions (\n    prescription_id character varying(64) NOT NULL, -- unique identifier for the prescription\n    record_id character varying(64) NOT NULL, -- FK linking to the medical record where it was prescribed\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    doctor_id character varying(64) NOT NULL, -- FK to prescribing doctor\n    medication_id character varying(64) NOT NULL, -- FK to medications table\n    dosage character varying(100) NOT NULL, -- e.g., '100mg', '1 tablet'\n    frequency character varying(100) NOT NULL, -- e.g., 'Once daily', 'Twice a day with meals'\n    route character varying(50), -- e.g., 'Oral', 'Topical', 'Intravenous'\n    start_date date NOT NULL, -- date prescription begins\n    end_date date, -- date prescription ends (if applicable)\n    quantity_dispensed numeric(10,2), -- amount dispensed (e.g., number of tablets)\n    refills_allowed integer NOT NULL DEFAULT 0, -- number of allowed refills\n    prescription_date timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (prescription_id)\n)\nCREATE TABLE healthcare.insurance_plans (\n    plan_id character varying(64) NOT NULL, -- unique identifier for the insurance plan\n    plan_name character varying(200) NOT NULL, -- name of the insurance plan\n    insurance_provider character varying(100) NOT NULL, -- name of the insurance company\n    plan_type character varying(50), -- e.g., PPO, HMO, EPO\n    contact_phone character varying(20), -- provider contact number\n    website character varying(255), -- provider website\n    PRIMARY KEY (plan_id)\n)\nCREATE TABLE healthcare.patient_insurance (\n    patient_insurance_id character varying(64) NOT NULL, -- unique identifier for this patient-plan link\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    plan_id character varying(64) NOT NULL, -- FK to insurance_plans table\n    policy_number character varying(100) NOT NULL, -- patient's policy number\n    group_number character varying(100), -- group number, if applicable\n    subscriber_name character varying(200), -- name of the primary policy holder\n    effective_date date NOT NULL, -- date the coverage begins\n    expiration_date date, -- date the coverage ends (if known)\n    is_primary boolean NOT NULL DEFAULT true, -- indicates if this is the primary insurance\n    PRIMARY KEY (patient_insurance_id),\n    UNIQUE (patient_id, plan_id, policy_number) -- ensure a patient doesn't have the same policy twice\n)\n"}
{"conversations": [{"role": "user", "content": "What is the current number of passengers at station with ID 'ST123' right now?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information on the current number of passengers at a station. The data I have access to only includes static details about stations such as their name, location, and number of platforms, not real-time passenger counts."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.stations (\n    station_id character varying(64) NOT NULL,  -- Unique identifier for the station\n    station_name character varying(128) NOT NULL, -- Name of the station\n    city character varying(100) NOT NULL, -- City where the station is located\n    state_province character varying(100), -- State or province\n    country_code character varying(3) NOT NULL, -- ISO country code\n    address text, -- Full address of the station\n    timezone character varying(64) NOT NULL, -- Timezone ID (e.g., 'America/New_York')\n    number_of_platforms integer NOT NULL DEFAULT 0, -- Total number of platforms\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- When the station record was created\n    last_updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- When the station record was last updated\n    PRIMARY KEY (station_id)\n)\n"}
{"conversations": [{"role": "user", "content": "How many distinct ports have been used by peers in the system?"}, {"role": "assistant", "content": "SELECT COUNT(DISTINCT port) AS distinct_port_count\nFROM trading_platform.peers;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.users ( user_id text PRIMARY KEY, username text, email text, password_hash text, created_at timestamp )\nCREATE TABLE trading_platform.wallets (\n    wallet_id character varying(64) NOT NULL,  -- unique identifier for the wallet\n    user_id character varying(64) NOT NULL, -- identifier of the user owning the wallet\n    address character varying(128) NOT NULL, -- address of the wallet\n    private_key text NOT NULL, -- private key of the wallet\n    created_at timestamp NOT NULL, -- time when the wallet was created\n    PRIMARY KEY (wallet_id)\n)\nCREATE TABLE trading_platform.orders ( order_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, wallet_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, order_type character varying(32) NOT NULL, quantity numeric(38,14) NOT NULL, price numeric(38,14) NOT NULL, status character varying(32) NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (order_id) )\nCREATE TABLE trading_platform.assets (\n    asset_id character varying(64) NOT NULL,  -- unique identifier for the asset\n    name character varying(128) NOT NULL, -- name of the asset\n    symbol character varying(32) NOT NULL, -- symbol of the asset\n    type character varying(32) NOT NULL, -- type of the asset (e.g., cryptocurrency, stock)\n    PRIMARY KEY (asset_id)\n)\nCREATE TABLE trading_platform.utxos (\n    utxo_id character varying(64) NOT NULL,  -- unique identifier for the UTXO\n    transaction_id character varying(64) NOT NULL, -- identifier of the transaction that created the UTXO\n    output_index integer NOT NULL, -- index of the output in the transaction\n    address character varying(128) NOT NULL, -- address that can spend the UTXO\n    amount numeric(38,14) NOT NULL, -- amount of the asset in the UTXO\n    spent boolean NOT NULL, -- whether the UTXO has been spent\n    PRIMARY KEY (utxo_id)\n)\nCREATE TABLE trading_platform.dapps ( dapp_id.text, name.text, description.text, url.text )\nCREATE TABLE trading_platform.peers ( peer_id character varying(64) NOT NULL, ip_address character varying(15) NOT NULL, port integer NOT NULL, last_seen timestamp NOT NULL, PRIMARY KEY (peer_id) )\nCREATE TABLE trading_platform.metadata (\n    metadata_id character varying(64) NOT NULL,  -- unique identifier for the metadata\n    asset_id character varying(64) NOT NULL, -- identifier of the asset the metadata is associated with\n    key character varying(128) NOT NULL, -- key of the metadata\n    value text NOT NULL, -- value of the metadata\n    PRIMARY KEY (metadata_id)\n)\nCREATE TABLE trading_platform.kyc_audit ( kyc_audit_id.text, user_id.text, status.text, reviewed_at.timestamp )\nCREATE TABLE trading_platform.logs (\n    log_id character varying(64) NOT NULL,  -- unique identifier for the log entry\n    user_id character varying(64), -- identifier of the user associated with the log entry\n    action character varying(128) NOT NULL, -- action performed\n    details text NOT NULL, -- details of the action\n    logged_at timestamp NOT NULL, -- time when the log entry was created\n    PRIMARY KEY (log_id)\n)\nCREATE TABLE trading_platform.notifications ( notification_id.text, user_id.text, message.text, sent_at.timestamp, read_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "Find receiver addresses that have received transactions from more than 5 distinct sender addresses. Show the receiver address and the count of distinct senders."}, {"role": "assistant", "content": "SELECT receiver_address, COUNT(DISTINCT sender_address) FROM blockchain.transactions GROUP BY receiver_address HAVING COUNT(DISTINCT sender_address) > 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE blockchain.transactions (\n    transaction_id character varying(64) NOT NULL,  -- unique identifier for the transaction\n    block_id character varying(64) NOT NULL, -- identifier of the block containing the transaction\n    sender_address character varying(128) NOT NULL, -- address of the sender\n    receiver_address character varying(128) NOT NULL, -- address of the receiver\n    amount numeric(38,14) NOT NULL, -- amount transferred\n    timestamp timestamp NOT NULL, -- time when the transaction was created\n    signature text NOT NULL, -- digital signature of the transaction\n    PRIMARY KEY (transaction_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Count the total number of premium payments made in the year 2024."}, {"role": "assistant", "content": "SELECT COUNT(*) FROM premium_payments WHERE EXTRACT(YEAR FROM payment_date) = 2024"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.customers ( customer_id text PRIMARY KEY, first_name text, last_name text, date_of_birth date, ssn_hash text, address_line1 text, address_line2 text, city text, state text, zip_code text, country text, phone_number text, email text, created_at timestamp, updated_at timestamp, status text )\nCREATE 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) )\nCREATE TABLE insurance.claims ( claim_id character varying(64) NOT NULL, policy_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, incident_date timestamp NOT NULL, reported_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, description text NOT NULL, estimated_loss numeric(15, 2), status character varying(30) NOT NULL, settlement_amount numeric(15, 2), settlement_date date, claim_handler_id character varying(64), police_report_number character varying(100), PRIMARY KEY (claim_id) )\nCREATE 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 )\nCREATE TABLE insurance.premium_payments ( payment_id text PRIMARY KEY, 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 )\n"}
{"conversations": [{"role": "user", "content": "What is the total and average amount of unspent UTXOs per address?"}, {"role": "assistant", "content": "SELECT\n  address,\n  COUNT(*) AS utxo_count,\n  SUM(amount) AS total_unspent_amount,\n  AVG(amount) AS average_unspent_amount\nFROM trading_platform.utxos\nWHERE spent = FALSE\nGROUP BY address;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )\nCREATE TABLE trading_platform.dapps ( dapp_id character varying(64) NOT NULL, name character varying(128) NOT NULL, description text NOT NULL, url character varying(256) NOT NULL, PRIMARY KEY (dapp_id) )\nCREATE TABLE trading_platform.logs ( log_id text PRIMARY KEY, user_id text, action text, details text, logged_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show me the top 5 narratives by market cap, along with their 24-hour trading volume and 7-day price change percentage."}, {"role": "assistant", "content": "SELECT narrative.text, volume_24h.numeric, price_change_percentage_7d.numeric FROM narrative_info ORDER BY market_cap.numeric DESC LIMIT 5;"}, {"role": "user", "content": "Can you also include the top 3 coins for each of these narratives?"}, {"role": "assistant", "content": "SELECT narrative.text, volume_24h.numeric, price_change_percentage_7d.numeric, top_3_coins.text FROM narrative_info ORDER BY market_cap.numeric DESC LIMIT 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE narrative_info ( narrative.text, top_3_coins.text, price_change_percentage_1h.numeric, price_change_percentage_24h.numeric, price_change_percentage_7d.numeric, market_cap.numeric, volume_24h.numeric, trend_rank.numeric, token_num.numeric )\n"}
{"conversations": [{"role": "user", "content": "Show me the top 5 users who have interacted with DApps, along with the count of distinct DApps they interacted with and their wallet addresses."}, {"role": "assistant", "content": "SELECT w.user_id, COUNT(DISTINCT d.dapp_id) AS dapp_count, w.address FROM trading_platform.wallets w JOIN trading_platform.dapps d ON 1=1 GROUP BY w.user_id, w.address ORDER BY dapp_count DESC LIMIT 5;"}, {"role": "user", "content": "This query doesn't properly show DApp interactions. Please modify it to correctly join with a table that records user-DApp interactions."}, {"role": "assistant", "content": "I notice there's no interaction table in the provided schema. Without a table recording user-DApp interactions, I cannot generate this query accurately. Would you like to see users who have wallets and DApps separately instead?"}, {"role": "user", "content": "You're right. Instead, show me users who have wallets but have never interacted with any DApps, along with their wallet addresses."}, {"role": "assistant", "content": "SELECT w.user_id, w.address FROM trading_platform.wallets w WHERE NOT EXISTS (SELECT 1 FROM trading_platform.dapps d WHERE 1=1) GROUP BY w.user_id, w.address;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.wallets ( wallet_id.text, user_id.text, address.text, private_key.text, created_at.timestamp )\nCREATE TABLE trading_platform.trades ( trade_id character varying(64) NOT NULL, order_id character varying(64) NOT NULL, buyer_id character varying(64) NOT NULL, seller_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, quantity numeric(38,14) NOT NULL, price numeric(38,14) NOT NULL, traded_at timestamp NOT NULL, PRIMARY KEY (trade_id) )\nCREATE TABLE trading_platform.assets ( asset_id.text, name.text, symbol.text, type.text )\nCREATE TABLE trading_platform.dapps (\n    dapp_id character varying(64) NOT NULL,  -- unique identifier for the DApp\n    name character varying(128) NOT NULL, -- name of the DApp\n    description text NOT NULL, -- description of the DApp\n    url character varying(256) NOT NULL, -- URL of the DApp\n    PRIMARY KEY (dapp_id)\n)\nCREATE TABLE trading_platform.metadata ( metadata_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, key character varying(128) NOT NULL, value text NOT NULL, PRIMARY KEY (metadata_id) )\n"}
{"conversations": [{"role": "user", "content": "I need to identify pairs of verified documents submitted by the same citizen. For each pair, display the citizen_id, the earlier document_id with its verification timestamp, and the later document_id with its verification timestamp."}, {"role": "assistant", "content": "SELECT\n  d1.citizen_id,\n  d1.document_id AS earlier_document_id,\n  d1.verification_timestamp AS earlier_verification,\n  d2.document_id AS later_document_id,\n  d2.verification_timestamp AS later_verification\nFROM government_services.documents d1\nJOIN government_services.documents d2\n  ON d1.citizen_id = d2.citizen_id\n  AND d1.verification_timestamp < d2.verification_timestamp\nWHERE d1.verification_status = 'Verified'\n  AND d2.verification_status = 'Verified';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.documents ( document_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, document_type character varying(100) NOT NULL, file_reference text NOT NULL, upload_timestamp timestamp NOT NULL, expiry_date date, verification_status character varying(30) DEFAULT 'Pending', verified_by_employee_id character varying(64), verification_timestamp timestamp, PRIMARY KEY (document_id) )\n"}
{"conversations": [{"role": "user", "content": "Find all in-game items that have a 'mana_cost' attribute in their attributes JSON. Show the item ID, item name, and the value of the 'mana_cost'."}, {"role": "assistant", "content": "SELECT item_id, item_name, attributes ->> 'mana_cost' AS mana_cost FROM gaming_technology.in_game_items WHERE attributes ? 'mana_cost'"}, {"role": "user", "content": "Now, only include items where the 'mana_cost' is greater than 50."}, {"role": "assistant", "content": "SELECT item_id, item_name, attributes ->> 'mana_cost' AS mana_cost FROM gaming_technology.in_game_items WHERE attributes ? 'mana_cost' AND (attributes ->> 'mana_cost')::int > 50"}, {"role": "user", "content": "Add the item's rarity and the title of the game it belongs to in the output."}, {"role": "assistant", "content": "SELECT t1.item_id, t1.item_name, t1.rarity, t2.title, t1.attributes ->> 'mana_cost' AS mana_cost FROM gaming_technology.in_game_items AS t1 JOIN gaming_technology.games AS t2 ON t1.game_id = t2.game_id WHERE t1.attributes ? 'mana_cost' AND (t1.attributes ->> 'mana_cost')::int > 50"}, {"role": "user", "content": "Filter the results to only include items from games in the 'Fantasy' genre."}, {"role": "assistant", "content": "SELECT t1.item_id, t1.item_name, t1.rarity, t2.title, t1.attributes ->> 'mana_cost' AS mana_cost FROM gaming_technology.in_game_items AS t1 JOIN gaming_technology.games AS t2 ON t1.game_id = t2.game_id WHERE t1.attributes ? 'mana_cost' AND (t1.attributes ->> 'mana_cost')::int > 50 AND t2.genre = 'Fantasy'"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE gaming_technology.developers ( developer_id uuid PRIMARY KEY, name text, country text, founded_year int, website text, created_at timestamptz )\nCREATE 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 )\nCREATE TABLE gaming_technology.servers ( server_id uuid PRIMARY KEY, game_id uuid, server_name text, region text, ip_address text, port int, current_players int, max_players int, status text, last_heartbeat timestamptz )\nCREATE TABLE gaming_technology.achievements ( achievement_id uuid PRIMARY KEY, game_id uuid, name text, description text, icon_url text, points int, hidden boolean )\nCREATE TABLE gaming_technology.player_achievements ( player_achievement_id uuid PRIMARY KEY, player_id uuid, achievement_id uuid, unlocked_at timestamptz )\nCREATE TABLE gaming_technology.in_game_items ( item_id uuid PRIMARY KEY, game_id uuid, item_name text, item_type text, description text, rarity text, cost_currency text, cost_amount numeric, attributes jsonb )\nCREATE TABLE gaming_technology.player_inventory ( inventory_id uuid PRIMARY KEY, player_id uuid, item_id uuid, quantity int, acquired_at timestamptz, instance_data jsonb )\n"}
{"conversations": [{"role": "user", "content": "Retrieve each agency’s name along with the count of accessible service locations it has in California."}, {"role": "assistant", "content": "SELECT\n  a.agency_name,\n  COUNT(l.location_id) AS accessible_location_count\nFROM government_services.agencies a\nJOIN government_services.service_locations l\n  ON a.agency_id = l.agency_id\nWHERE l.is_accessible = TRUE\n  AND l.state = 'California'\nGROUP BY a.agency_name;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id text PRIMARY KEY, 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 )\nCREATE 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 )\nCREATE TABLE government_services.services ( service_id text PRIMARY KEY, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days int, is_active boolean, online_application_url text )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List all ERC20 tokens where the price is between $1 and $10, including their names, symbols, and contract addresses."}, {"role": "assistant", "content": "SELECT tm.name, tm.symbol, tm.contract_address FROM token_metas tm JOIN token_prices_latest tpl ON tm.contract_address = tpl.contract_address WHERE tm.is_erc20 = 1 AND tpl.price BETWEEN 1 AND 10;"}, {"role": "user", "content": "I think there's an error in your query - the token_prices_latest table isn't in the schema. Can you modify it to use the token_balances table instead?"}, {"role": "assistant", "content": "SELECT tm.name, tm.symbol, tm.contract_address FROM token_metas tm JOIN token_balances tb ON tm.contract_address = tb.wallet_address WHERE tm.is_erc20 = 1 AND CAST(tb.amount AS decimal) BETWEEN 1 AND 10;"}, {"role": "user", "content": "That doesn't seem right either. Let's just get the basic ERC20 token information without price filtering for now."}, {"role": "assistant", "content": "SELECT name, symbol, contract_address FROM token_metas WHERE is_erc20 = 1 LIMIT 100;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE erc1155_approval_for_all ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, transaction_index integer NOT NULL, transaction_hash varchar(66) NOT NULL, log_index integer NOT NULL, contract_address varchar(42) NOT NULL )\nCREATE TABLE erc20_balances ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address text, wallet_address text, amount text, pk integer )\nCREATE TABLE nft_holders ( block_number bigint, contract_address text, wallet_address text, token_id text, contract_type text, amount text, pk text )\nCREATE TABLE nft_holder_historical ( block_number.bigint, contract_address.text, wallet_address.text, token_id.text, contract_type.text, amount.text, pk.integer )\nCREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )\nCREATE 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 )\nCREATE TABLE erc20_approval ( block_number bigint NOT NULL, block_timestamp timestamp(6) NOT NULL, transaction_index integer NOT NULL, transaction_hash varchar NOT NULL, log_index integer NOT NULL, contract_address varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick text, wallet_address text, total_supply decimal, amount decimal )\nCREATE TABLE token_info (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    tick varchar NOT NULL, -- Token tick\n    max_supply decimal(38,0) NOT NULL, -- Max supply\n    lim decimal(38,0) NOT NULL, -- Limit of each mint\n    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint\n    dec integer NOT NULL, -- Decimal for minimum divie\n    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)\n)\nCREATE 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 )\nCREATE TABLE mud_holesky_redstone ( address varchar NOT NULL, table_id varchar NOT NULL, key_bytes varchar NOT NULL, key0 varchar NOT NULL, key1 varchar NOT NULL, static_data varchar NOT NULL, encoded_lengths varchar NOT NULL, dynamic_data varchar NOT NULL, is_deleted boolean NOT NULL, block_number bigint NOT NULL, log_index bigint NOT NULL )\nCREATE TABLE token_balances_bitcoin ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply varchar, amount varchar )\nCREATE 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 )\nCREATE 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 )\nCREATE TABLE token_balances_avalanche (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar(20) NOT NULL, -- Ticker: Identifier of the inscription\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply decimal(38,0) NOT NULL, -- Max supply: Set max supply of the inscription\n    amount decimal(38,0) NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "List the names of services for which documents are set to expire in the next 90 days."}, {"role": "assistant", "content": "SELECT DISTINCT T1.service_name FROM government_services.services AS T1 JOIN applications AS T2 ON T1.service_id = T2.service_id JOIN government_services.documents AS T3 ON T2.application_id = T3.application_id WHERE T3.expiry_date IS NOT NULL AND T3.expiry_date BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '90 days'"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.services ( service_id text PRIMARY KEY, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days int, is_active boolean, online_application_url text )\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Give me the total number of reservations and the sum of total_amount by month for the year 2023."}, {"role": "assistant", "content": "SELECT DATE_TRUNC('month', check_in_date) AS month,\n       COUNT(*)                         AS reservation_count,\n       SUM(total_amount)               AS total_revenue\nFROM hospitality_technology.reservations\nWHERE EXTRACT(YEAR FROM check_in_date) = 2023\nGROUP BY DATE_TRUNC('month', check_in_date)\nORDER BY month;"}, {"role": "user", "content": "Actually, I only want reservations with status 'CheckedOut' or 'Completed'."}, {"role": "assistant", "content": "SELECT DATE_TRUNC('month', check_in_date) AS month,\n       COUNT(*)                         AS reservation_count,\n       SUM(total_amount)               AS total_revenue\nFROM hospitality_technology.reservations\nWHERE EXTRACT(YEAR FROM check_in_date) = 2023\n  AND status IN ('CheckedOut', 'Completed')\nGROUP BY DATE_TRUNC('month', check_in_date)\nORDER BY month;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.reservations ( reservation_id text PRIMARY KEY, property_id text, guest_id text, room_id text, room_type_id text, check_in_date date, check_out_date date, actual_check_in_ts timestamp, actual_check_out_ts timestamp, num_adults int, num_children int, status text, booking_source text, rate_plan_id text, total_amount numeric, amount_paid numeric, special_requests text, created_at timestamp, updated_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "What are the safety ratings or crash statistics for the Boeing 787 Dreamliner?"}, {"role": "assistant", "content": "I'm sorry, but I don't have access to safety ratings or crash statistics for specific aircraft models like the Boeing 787 Dreamliner. My data is limited to the information in the aircraft_models table, which includes details such as model name, manufacturer, passenger capacity, and technical specifications. For safety-related information, I recommend consulting official aviation authorities or safety reports."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE manufacturing.aircraft_models ( model_id text, model_name text, manufacturer text, passenger_capacity integer, max_range_km integer, engine_type text, wingspan_m numeric, status text, first_flight_date date )\n"}
{"conversations": [{"role": "user", "content": "For each category, list all pairs of services where one is active and the other is inactive. Show the category, active service name, and inactive service name."}, {"role": "assistant", "content": "SELECT a.category,\n       a.service_name AS active_service,\n       i.service_name AS inactive_service\nFROM government_services.services a\nJOIN government_services.services i\n  ON a.category = i.category\nWHERE a.is_active = TRUE\n  AND i.is_active = FALSE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.services ( service_id text, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days integer, is_active boolean, online_application_url text )\n"}
{"conversations": [{"role": "user", "content": "List all managers (employees who have other employees reporting to them) along with the count of their direct reports, showing only those with more than 5 reports."}, {"role": "assistant", "content": "SELECT e.employee_id, e.first_name, e.last_name, COUNT(r.employee_id) as direct_reports_count FROM financial_services.employees e JOIN financial_services.employees r ON e.employee_id = r.manager_id WHERE e.status = 'Active' GROUP BY e.employee_id, e.first_name, e.last_name HAVING COUNT(r.employee_id) > 5 ORDER BY direct_reports_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Can you help me retrieve the list of components made of a specific material along with their supplier details?"}, {"role": "assistant", "content": "SMEMBERS material_components:mat:TI64\nHGETALL component:<component_id>\nHGET component:<component_id> supplier_id"}, {"role": "user", "content": "Can you also include the part number for each component in the result?"}, {"role": "assistant", "content": "SMEMBERS material_components:mat:TI64\nHGETALL component:<component_id>\nHGET component:<component_id> supplier_id\nHGET component:<component_id> part_number"}, {"role": "user", "content": "If I want to filter out components from a specific supplier, how can I modify the query?"}, {"role": "assistant", "content": "SMEMBERS material_components:mat:TI64\nHGETALL component:<component_id>\nHGET component:<component_id> supplier_id\nHGET component:<component_id> part_number\nIF HGET component:<component_id> supplier_id != 'sup:ACME_AERO' THEN INCLUDE"}, {"role": "user", "content": "Can you also sort the results based on the part number?"}, {"role": "assistant", "content": "SMEMBERS material_components:mat:TI64\nHGETALL component:<component_id>\nHGET component:<component_id> supplier_id\nHGET component:<component_id> part_number\nIF HGET component:<component_id> supplier_id != 'sup:ACME_AERO' THEN INCLUDE\nSORT BY part_number 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. \n##Table Structure\nUse Hashes. Key pattern: 'component:<component_id>'. Example: HSET component:LGSTRUT01 part_number \"PN-5521-A\" component_name \"Landing Gear Strut\" material_id \"mat:TI64\" supplier_id \"sup:ACME_AERO\" ... Consider Sets for reverse lookups (e.g., 'material_components:<material_id>' -> Set<component_id>).\n"}
{"conversations": [{"role": "user", "content": "Can you narrow this down to only show cases where the case type is 'Criminal'?"}, {"role": "assistant", "content": "SELECT case_name, case_number, date_opened FROM legal_services.cases WHERE lead_lawyer_id = 'lawyer_abc' AND status = 'Open' AND case_type = 'Criminal';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.cases ( case_id.text, case_number.text, case_name.text, client_id.text, lead_lawyer_id.text, case_type.text, status.text, date_opened.timestamp, date_closed.timestamp, description.text, court_jurisdiction.text )\n"}
{"conversations": [{"role": "user", "content": "What is the average ROI for all smart money addresses on the Binance chain?"}, {"role": "assistant", "content": "SELECT AVG(roi) FROM smart_money_profit WHERE chain = 'Binance';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE smart_money_profit ( address character varying(100) NOT NULL, -- the user's address rank INT, -- the rank of the address in trade performance, value 1 expresses the best address. profit numeric(38,6), -- the profit user made in a month roi numeric(38,2), -- the roi of the user in a month realized_ratio numeric(38,2), -- the percentage of the user's realized profit most_profit_token character varying(100), -- the token symbol of the user's most profitable trade last_trade_time character varying(100), -- the last trade time of the user chain character varying(100), -- the chain that the address resides PRIMARY KEY (address, chain) )\n"}
{"conversations": [{"role": "user", "content": "Show me the usernames along with the names of group chats they are participating in and the dates they joined each group."}, {"role": "assistant", "content": "SELECT u.username, c.group_name, cp.joined_at\nFROM social_media.conversation_participants cp\nJOIN social_media.users u ON cp.user_id = u.user_id\nJOIN social_media.conversations c ON cp.conversation_id = c.conversation_id\nWHERE c.is_group_chat = TRUE;"}, {"role": "user", "content": "Only display records where the user joined after January 1, 2024."}, {"role": "assistant", "content": "SELECT u.username, c.group_name, cp.joined_at\nFROM social_media.conversation_participants cp\nJOIN social_media.users u ON cp.user_id = u.user_id\nJOIN social_media.conversations c ON cp.conversation_id = c.conversation_id\nWHERE c.is_group_chat = TRUE\nAND cp.joined_at > '2024-01-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\nCREATE TABLE social_media.posts ( post_id text, 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 )\nCREATE TABLE social_media.comments ( comment_id text, post_id text, user_id text, parent_comment_id text, content text, created_at timestamp, updated_at timestamp )\nCREATE TABLE social_media.likes ( like_id text, user_id text, post_id text, comment_id text, created_at timestamp )\nCREATE TABLE social_media.follows ( follow_id text, follower_user_id text, following_user_id text, created_at timestamp )\nCREATE TABLE social_media.hashtags ( hashtag_id text, tag_name text, created_at timestamp )\nCREATE TABLE social_media.messages ( message_id text, conversation_id text, sender_user_id text, content text, media_url text, media_type text, sent_at timestamp, read_at timestamp )\nCREATE TABLE social_media.conversations ( conversation_id text, created_at timestamp, last_message_at timestamp, is_group_chat boolean, group_name text )\nCREATE TABLE social_media.conversation_participants ( participant_id text, conversation_id text, user_id text, joined_at timestamp, last_read_at timestamp )\nCREATE TABLE social_media.user_settings ( setting_id text, user_id text, theme text, email_notifications_enabled boolean, push_notifications_enabled boolean, private_profile boolean, updated_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Give me the total billed amount for each invoice in 2024."}, {"role": "assistant", "content": "SELECT invoice_id, SUM(hours_spent * billing_rate) AS total_billed_amount FROM legal_services.time_entries WHERE is_billed = TRUE AND EXTRACT(YEAR FROM date_worked) = 2024 GROUP BY invoice_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.time_entries ( entry_id text PRIMARY KEY, case_id text, lawyer_id text, date_worked date, hours_spent numeric, billing_rate numeric, description text, is_billable bool, is_billed bool, invoice_id text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Which employees have verified more than 5 documents in the last 30 days? Return the employee's full name, department, and the number of verifications."}, {"role": "assistant", "content": "SELECT e.first_name || ' ' || e.last_name AS full_name, e.department, COUNT(d.document_id) AS verification_count\nFROM government_services.documents d\nJOIN government_services.employees e ON d.verified_by_employee_id = e.employee_id\nWHERE d.verification_status = 'Verified'\n  AND d.verification_timestamp >= now() - interval '30 days'\nGROUP BY e.first_name, e.last_name, e.department\nHAVING COUNT(d.document_id) > 5;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.services ( service_id character varying(64) NOT NULL, agency_id character varying(64) NOT NULL, service_name character varying(255) NOT NULL, description text, category character varying(100), eligibility_criteria text, standard_fee numeric(10, 2) DEFAULT 0.00, average_processing_time_days integer, is_active boolean DEFAULT true, online_application_url character varying(255), PRIMARY KEY (service_id) )\nCREATE TABLE government_services.applications ( application_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, service_id character varying(64) NOT NULL, submitted_at timestamp NOT NULL, status character varying(50) NOT NULL, last_updated_at timestamp NOT NULL, assigned_employee_id character varying(64), decision_date date, notes text, reference_number character varying(100) UNIQUE, PRIMARY KEY (application_id) )\nCREATE TABLE government_services.documents ( document_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, document_type character varying(100) NOT NULL, file_reference text NOT NULL, upload_timestamp timestamp NOT NULL, expiry_date date, verification_status character varying(30) DEFAULT 'Pending', verified_by_employee_id character varying(64), verification_timestamp timestamp, PRIMARY KEY (document_id) )\nCREATE TABLE government_services.employees ( employee_id character varying(64) NOT NULL, agency_id character varying(64) NOT NULL, 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, access_level character varying(50), manager_employee_id character varying(64), PRIMARY KEY (employee_id) )\nCREATE 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) )\n"}
{"conversations": [{"role": "user", "content": "For each lawyer, show their first name, last name, and the total number of documents they have uploaded, along with the names of the law firms they belong to."}, {"role": "assistant", "content": "SELECT l.first_name, l.last_name, f.firm_name, COUNT(d.document_id) AS document_count\nFROM legal_services.lawyers l\nLEFT JOIN legal_services.law_firms f ON l.firm_id = f.firm_id\nLEFT JOIN legal_services.documents d ON l.lawyer_id = d.uploaded_by_lawyer_id\nGROUP BY l.lawyer_id, l.first_name, l.last_name, f.firm_name;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.clients ( client_id text PRIMARY KEY, first_name text, last_name text, company_name text, email text UNIQUE, phone text, address text, date_registered timestamp, status text )\nCREATE TABLE legal_services.lawyers (\n    lawyer_id character varying(64) NOT NULL,  -- unique identifier for the lawyer\n    first_name character varying(100) NOT NULL, -- lawyer's first name\n    last_name character varying(100) NOT NULL, -- lawyer's last name\n    bar_number character varying(64) UNIQUE NOT NULL, -- lawyer's bar association number\n    firm_id character varying(64), -- FK to law_firms table\n    email character varying(128) UNIQUE NOT NULL, -- lawyer's professional email\n    phone character varying(32), -- lawyer's contact phone number\n    specialization text, -- areas of legal expertise\n    hire_date timestamp NOT NULL, -- date the lawyer was hired or joined\n    is_partner boolean DEFAULT false, -- flag indicating if the lawyer is a partner\n    PRIMARY KEY (lawyer_id)\n)\nCREATE TABLE legal_services.law_firms ( firm_id text PRIMARY KEY, firm_name text, address text, phone text, website text, founded_date date, managing_partner_id text )\nCREATE TABLE legal_services.documents (\n    document_id character varying(64) NOT NULL,  -- unique identifier for the document\n    case_id character varying(64) NOT NULL, -- FK to cases table\n    document_name character varying(255) NOT NULL, -- name of the document file\n    document_type character varying(100), -- e.g., Pleading, Contract, Evidence, Correspondence\n    storage_path text NOT NULL, -- path or reference to the document storage location\n    uploaded_by_lawyer_id character varying(64), -- FK to lawyers table (who uploaded it)\n    upload_timestamp timestamp NOT NULL, -- time the document was uploaded\n    version integer DEFAULT 1, -- document version number\n    description text, -- brief description or notes about the document\n    PRIMARY KEY (document_id)\n)\nCREATE TABLE legal_services.time_entries (\n    entry_id character varying(64) NOT NULL,  -- unique identifier for the time entry\n    case_id character varying(64) NOT NULL, -- FK to cases table\n    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table (who performed the work)\n    date_worked date NOT NULL, -- date the work was performed\n    hours_spent numeric(5, 2) NOT NULL CHECK (hours_spent > 0), -- duration of work in hours (e.g., 1.5 for 1h 30m)\n    billing_rate numeric(10, 2) NOT NULL, -- hourly rate applied for this entry\n    description text NOT NULL, -- detailed description of the work performed\n    is_billable boolean DEFAULT true, -- whether this time entry is billable to the client\n    is_billed boolean DEFAULT false, -- whether this entry has been included in an invoice\n    invoice_id character varying(64), -- FK to invoices table (once billed)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the entry was recorded\n    PRIMARY KEY (entry_id)\n)\nCREATE TABLE legal_services.appointments (\n    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment\n    client_id character varying(64) NOT NULL, -- FK to clients table\n    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table\n    case_id character varying(64), -- FK to cases table (optional, if related to a specific case)\n    start_time timestamp NOT NULL, -- scheduled start date and time\n    end_time timestamp NOT NULL, -- scheduled end date and time\n    location text, -- location of the meeting (address or virtual link)\n    subject character varying(255), -- subject or purpose of the appointment\n    notes text, -- additional notes for the appointment\n    status character varying(50) NOT NULL, -- e.g., Scheduled, Completed, Canceled, Rescheduled\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,\n    PRIMARY KEY (appointment_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me all customers who have missing contact information (either phone number or email is null), along with their state and city."}, {"role": "assistant", "content": "SELECT first_name, last_name, state, city FROM insurance.customers WHERE phone_number IS NULL OR email IS NULL;"}, {"role": "user", "content": "Now filter these to only show customers from Florida or New York who were created in the last year."}, {"role": "assistant", "content": "SELECT first_name, last_name, state, city FROM insurance.customers WHERE (phone_number IS NULL OR email IS NULL) AND state IN ('Florida', 'New York') AND created_at >= CURRENT_DATE - INTERVAL '1 year';"}, {"role": "user", "content": "I also want to see when these customers were last updated (updated_at field)."}, {"role": "assistant", "content": "SELECT first_name, last_name, state, city, updated_at FROM insurance.customers WHERE (phone_number IS NULL OR email IS NULL) AND state IN ('Florida', 'New York') AND created_at >= CURRENT_DATE - INTERVAL '1 year';"}, {"role": "user", "content": "Finally, order the results by state first, then by the most recently updated customers first."}, {"role": "assistant", "content": "SELECT first_name, last_name, state, city, updated_at FROM insurance.customers WHERE (phone_number IS NULL OR email IS NULL) AND state IN ('Florida', 'New York') AND created_at >= CURRENT_DATE - INTERVAL '1 year' ORDER BY state, updated_at DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE insurance.customers (\n    customer_id character varying(64) NOT NULL,  -- unique identifier for the customer\n    first_name character varying(100) NOT NULL, -- customer's first name\n    last_name character varying(100) NOT NULL, -- customer's last name\n    date_of_birth date NOT NULL, -- customer's date of birth\n    ssn_hash character varying(128), -- Hashed social security number (or national ID)\n    address_line1 character varying(255) NOT NULL,\n    address_line2 character varying(255),\n    city character varying(100) NOT NULL,\n    state character varying(50) NOT NULL,\n    zip_code character varying(20) NOT NULL,\n    country character varying(50) NOT NULL DEFAULT 'USA',\n    phone_number character varying(30),\n    email character varying(128) UNIQUE, -- unique email address\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the customer record was created\n    updated_at timestamp, -- when the customer record was last updated\n    status character varying(20) NOT NULL DEFAULT 'Active', -- e.g., Active, Inactive, Prospect\n    PRIMARY KEY (customer_id)\n)\n"}
{"conversations": [{"role": "user", "content": "How many policies were canceled in the previous month, grouped by cancellation reason?"}, {"role": "assistant", "content": "SELECT cancellation_reason,\n       COUNT(*) AS canceled_count\nFROM insurance.policies\nWHERE cancellation_date BETWEEN date_trunc('month', CURRENT_DATE) - INTERVAL '1 month'\n                             AND date_trunc('month', CURRENT_DATE) - INTERVAL '1 day'\nGROUP BY cancellation_reason;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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 )\n"}
{"conversations": [{"role": "user", "content": "Find pairs of BUY and SELL trades from the trades table for the same account that occurred on the same settlement_date and had matching quantities."}, {"role": "assistant", "content": "SELECT\n  a.trade_id AS buy_trade_id,\n  b.trade_id AS sell_trade_id,\n  a.account_id,\n  a.settlement_date,\n  a.quantity\nFROM financial_services.trades a\nJOIN financial_services.trades b\n  ON a.account_id = b.account_id\n  AND a.settlement_date = b.settlement_date\n  AND a.quantity = b.quantity\nWHERE a.trade_type = 'BUY'\n  AND b.trade_type = 'SELL';"}, {"role": "user", "content": "Only include pairs where the execution_venue is different between the two trades."}, {"role": "assistant", "content": "SELECT\n  a.trade_id AS buy_trade_id,\n  b.trade_id AS sell_trade_id,\n  a.account_id,\n  a.settlement_date,\n  a.quantity\nFROM financial_services.trades a\nJOIN financial_services.trades b\n  ON a.account_id = b.account_id\n  AND a.settlement_date = b.settlement_date\n  AND a.quantity = b.quantity\nWHERE a.trade_type = 'BUY'\n  AND b.trade_type = 'SELL'\n  AND a.execution_venue <> b.execution_venue;"}, {"role": "user", "content": "Sort the results by account_id ascending and settlement_date descending."}, {"role": "assistant", "content": "SELECT\n  a.trade_id AS buy_trade_id,\n  b.trade_id AS sell_trade_id,\n  a.account_id,\n  a.settlement_date,\n  a.quantity\nFROM financial_services.trades a\nJOIN financial_services.trades b\n  ON a.account_id = b.account_id\n  AND a.settlement_date = b.settlement_date\n  AND a.quantity = b.quantity\nWHERE a.trade_type = 'BUY'\n  AND b.trade_type = 'SELL'\n  AND a.execution_venue <> b.execution_venue\nORDER BY a.account_id ASC, a.settlement_date DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE financial_services.trades ( trade_id character varying(64) NOT NULL, account_id character varying(64) NOT NULL, security_id character varying(64) NOT NULL, order_id character varying(64), trade_type character varying(10) NOT NULL, quantity numeric(19, 8) NOT NULL, price_per_unit numeric(19, 8) NOT NULL, total_amount numeric(19, 4) NOT NULL, commission numeric(10, 4), trade_timestamp timestamp NOT NULL, settlement_date date, status character varying(32) NOT NULL, execution_venue character varying(100), PRIMARY KEY (trade_id), FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id), FOREIGN KEY (security_id) REFERENCES financial_services.securities(security_id) )\nCREATE TABLE financial_services.employees ( employee_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, job_title character varying(100) NOT NULL, department character varying(100), branch_id character varying(64), email character varying(128) NOT NULL UNIQUE, phone_extension character varying(20), hire_date date NOT NULL, termination_date date, manager_id character varying(64), status character varying(32) NOT NULL, PRIMARY KEY (employee_id), FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id) )\n"}
{"conversations": [{"role": "user", "content": "Retrieve the agency name and the most recent notification sent date for each agency, considering only notifications related to agencies."}, {"role": "assistant", "content": "SELECT a.agency_name, MAX(n.sent_at) AS last_notification_date\nFROM government_services.agencies a\nJOIN government_services.notifications n\n  ON n.related_entity_type = 'Agency'\n  AND n.related_entity_id = a.agency_id\nGROUP BY a.agency_name;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE 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) )\nCREATE TABLE government_services.notifications (\n    notification_id character varying(64) NOT NULL, -- unique identifier for the notification\n    citizen_id character varying(64) NOT NULL, -- FK to citizens table\n    application_id character varying(64), -- FK to applications table (optional)\n    message_subject character varying(255),\n    message_body text NOT NULL,\n    channel character varying(30) NOT NULL, -- e.g., Email, SMS, Portal Message, Mail\n    sent_at timestamp NOT NULL,\n    status character varying(30) NOT NULL, -- e.g., Queued, Sent, Delivered, Failed, Read\n    related_entity_type character varying(50), -- e.g., Application, Appointment, Document Request\n    related_entity_id character varying(64), -- ID of the related entity\n    PRIMARY KEY (notification_id)\n)\n"}