{"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": "Show all items where the attributes JSON has a non-null 'defense' value. Display item_id, item_name, rarity, and the defense value."}, {"role": "assistant", "content": "SELECT item_id, item_name, rarity, (attributes->>'defense')::numeric AS defense FROM gaming_technology.in_game_items WHERE (attributes->>'defense') IS NOT NULL;"}, {"role": "user", "content": "Only include items with defense greater than 100. Also, show their cost_amount."}, {"role": "assistant", "content": "SELECT item_id, item_name, rarity, (attributes->>'defense')::numeric AS defense, cost_amount FROM gaming_technology.in_game_items WHERE (attributes->>'defense') IS NOT NULL AND (attributes->>'defense')::numeric > 100;"}, {"role": "user", "content": "Now, also include all items of type 'Shield', even if they don't have a 'defense' attribute, but show defense as NULL for those."}, {"role": "assistant", "content": "SELECT item_id, item_name, rarity, (attributes->>'defense')::numeric AS defense, cost_amount FROM gaming_technology.in_game_items WHERE ( (attributes->>'defense') IS NOT NULL AND (attributes->>'defense')::numeric > 100 ) OR item_type = 'Shield';"}, {"role": "user", "content": "Order the results by defense in descending order, with NULLs last."}, {"role": "assistant", "content": "SELECT item_id, item_name, rarity, (attributes->>'defense')::numeric AS defense, cost_amount FROM gaming_technology.in_game_items WHERE ( (attributes->>'defense') IS NOT NULL AND (attributes->>'defense')::numeric > 100 ) OR item_type = 'Shield' ORDER BY defense DESC NULLS LAST;"}], "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.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 )\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": "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": "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 the first name, last name, and job title for all employees."}, {"role": "assistant", "content": "SELECT first_name, last_name, job_title FROM financial_services.employees;"}, {"role": "user", "content": "Only show employees who are currently active."}, {"role": "assistant", "content": "SELECT first_name, last_name, job_title FROM financial_services.employees WHERE status = 'Active';"}, {"role": "user", "content": "Additionally, include their email address in the result."}, {"role": "assistant", "content": "SELECT first_name, last_name, job_title, email FROM financial_services.employees WHERE 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 financial_services.customers ( customer_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, date_of_birth date NOT NULL, ssn_hash character varying(128), address text NOT NULL, city character varying(100) NOT NULL, state character varying(50) NOT NULL, zip_code character varying(20) NOT NULL, country character varying(50) NOT NULL, email character varying(128) UNIQUE, phone_number character varying(32), created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, status character varying(32) NOT NULL, risk_profile character varying(50), PRIMARY KEY (customer_id) )\nCREATE TABLE financial_services.accounts ( account_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, account_number character varying(128) NOT NULL UNIQUE, account_type character varying(50) NOT NULL, balance numeric(19, 4) NOT NULL DEFAULT 0.00, currency character varying(3) NOT NULL, opened_date date NOT NULL, status character varying(32) NOT NULL, interest_rate numeric(5, 4), last_updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (account_id), FOREIGN KEY (customer_id) REFERENCES financial_services.customers(customer_id) )\nCREATE TABLE financial_services.securities ( security_id character varying(64) NOT NULL, ticker_symbol character varying(20) NOT NULL UNIQUE, isin_code character varying(12) UNIQUE, cusip_code character varying(9) UNIQUE, security_name text NOT NULL, security_type character varying(50) NOT NULL, exchange character varying(50), currency character varying(3) NOT NULL, issuer_name character varying(255), sector character varying(100), last_updated timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (security_id) )\nCREATE TABLE financial_services.market_data ( data_point_id bigserial NOT NULL, security_id character varying(64) NOT NULL, data_timestamp timestamp NOT NULL, open_price numeric(19, 8), high_price numeric(19, 8), low_price numeric(19, 8), close_price numeric(19, 8) NOT NULL, adjusted_close_price numeric(19, 8), volume bigint, source character varying(50), PRIMARY KEY (data_point_id), UNIQUE (security_id, data_timestamp), FOREIGN KEY (security_id) REFERENCES financial_services.securities(security_id) )\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": "Show all achievements for games developed in Germany, including achievement names and their point values."}, {"role": "assistant", "content": "SELECT a.name AS achievement_name, a.points\nFROM gaming_technology.achievements a\nJOIN gaming_technology.games g ON a.game_id = g.game_id\nJOIN gaming_technology.developers d ON g.developer_id = d.developer_id\nWHERE d.country = 'Germany';"}, {"role": "user", "content": "Only include achievements with more than 50 points."}, {"role": "assistant", "content": "SELECT a.name AS achievement_name, a.points\nFROM gaming_technology.achievements a\nJOIN gaming_technology.games g ON a.game_id = g.game_id\nJOIN gaming_technology.developers d ON g.developer_id = d.developer_id\nWHERE d.country = 'Germany' AND a.points > 50;"}, {"role": "user", "content": "Include the title of the game for each achievement and order the list by points descending."}, {"role": "assistant", "content": "SELECT g.title AS game_title, a.name AS achievement_name, a.points\nFROM gaming_technology.achievements a\nJOIN gaming_technology.games g ON a.game_id = g.game_id\nJOIN gaming_technology.developers d ON g.developer_id = d.developer_id\nWHERE d.country = 'Germany' AND a.points > 50\nORDER BY a.points DESC;"}, {"role": "user", "content": "I got a column 'points' does not exist error. Can you ensure all referenced columns are correct?"}, {"role": "assistant", "content": "SELECT g.title AS game_title, a.name AS achievement_name, a.points\nFROM gaming_technology.achievements a\nJOIN gaming_technology.games g ON a.game_id = g.game_id\nJOIN gaming_technology.developers d ON g.developer_id = d.developer_id\nWHERE d.country = 'Germany' AND a.points > 50\nORDER BY a.points 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 ( player_id uuid, username text, email text, password_hash text, registration_date timestamp with time zone, last_login timestamp with time zone, country_code text, status text, profile_data jsonb )\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, name text, country text, founded_year integer, website text, created_at timestamp with time zone )\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.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 timestamp with time zone )\n"}
{"conversations": [{"role": "user", "content": "Show me all active electric vehicles along with their make, model, and license plate, ordered by acquisition date with the newest first."}, {"role": "assistant", "content": "SELECT vehicle_id, make, model, license_plate, acquisition_date FROM transportation.vehicles WHERE status = 'active' AND fuel_type = 'electric' ORDER BY acquisition_date DESC;"}, {"role": "user", "content": "Now include the depot_id for these vehicles and filter to only show vehicles acquired in the last 2 years."}, {"role": "assistant", "content": "SELECT vehicle_id, make, model, license_plate, acquisition_date, depot_id FROM transportation.vehicles WHERE status = 'active' AND fuel_type = 'electric' AND acquisition_date >= CURRENT_DATE - INTERVAL '2 years' ORDER BY acquisition_date DESC;"}, {"role": "user", "content": "Can you also include the vehicle's capacity and order the results by capacity in descending order?"}, {"role": "assistant", "content": "SELECT vehicle_id, make, model, license_plate, acquisition_date, depot_id, capacity FROM transportation.vehicles WHERE status = 'active' AND fuel_type = 'electric' AND acquisition_date >= CURRENT_DATE - INTERVAL '2 years' ORDER BY capacity 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.vehicles ( vehicle_id character varying(64) NOT NULL, license_plate character varying(32) NOT NULL UNIQUE, vin character varying(17) UNIQUE, make character varying(64) NOT NULL, model character varying(64) NOT NULL, year integer NOT NULL, type character varying(32) NOT NULL, capacity integer, fuel_type character varying(32) NOT NULL, status character varying(32) NOT NULL, depot_id character varying(64), acquisition_date date, PRIMARY KEY (vehicle_id) )\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": "Provide a list of all employees and their corresponding managers. Please display the full name for both the employee and their manager."}, {"role": "assistant", "content": "SELECT e.first_name || ' ' || e.last_name AS employee_name, m.first_name || ' ' || m.last_name AS manager_name FROM financial_services.employees AS e LEFT JOIN financial_services.employees AS m ON e.manager_id = m.employee_id"}, {"role": "user", "content": "Restrict the list to only include employees who are currently in 'Active' status."}, {"role": "assistant", "content": "SELECT e.first_name || ' ' || e.last_name AS employee_name, m.first_name || ' ' || m.last_name AS manager_name FROM financial_services.employees AS e LEFT JOIN financial_services.employees AS m ON e.manager_id = m.employee_id WHERE e.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 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": "Find all events that occurred in transactions involving token transfers from a specific address '0x1234', showing the event name and token transfer value."}, {"role": "assistant", "content": "SELECT e.event_name, tt.value FROM web3.events e JOIN web3.token_transfers tt ON e.transaction_id = tt.transaction_id WHERE tt.from_address = '0x1234';"}], "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 text PRIMARY KEY, contract_id text, event_name text, data text, emitted_at timestamp, transaction_id text, log_index int )\nCREATE TABLE web3.token_transfers ( transfer_id text PRIMARY KEY, token_id text, from_address text, to_address text, value numeric, transaction_id text, log_index int )\n"}
{"conversations": [{"role": "user", "content": "Find all wallets that were created on the same day and list their wallet IDs, addresses, and the creation date."}, {"role": "assistant", "content": "SELECT w1.wallet_id, w1.address, w1.created_at::date AS creation_date FROM web3.wallets w1 JOIN (SELECT created_at::date AS creation_date FROM web3.wallets GROUP BY created_at::date HAVING COUNT(*) > 1) w2 ON w1.created_at::date = w2.creation_date ORDER BY creation_date, w1.wallet_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.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": "List all vehicles and their last maintenance service date along with the odometer reading, including only those that have not had a fuel refill in the past 30 days."}, {"role": "assistant", "content": "SELECT m.vehicle_id,\n       m.last_service_date,\n       m.last_odometer\nFROM (\n  SELECT l.vehicle_id,\n         MAX(l.service_date) AS last_service_date,\n         (SELECT odometer_reading\n          FROM transportation.maintenance_logs\n          WHERE vehicle_id = l.vehicle_id\n          ORDER BY service_date DESC\n          LIMIT 1) AS last_odometer\n  FROM transportation.maintenance_logs l\n  GROUP BY l.vehicle_id\n) AS m\nLEFT JOIN (\n  SELECT fl.vehicle_id,\n         MAX(fl.log_timestamp) AS last_fuel_date\n  FROM transportation.fuel_logs fl\n  GROUP BY fl.vehicle_id\n) AS f ON m.vehicle_id = f.vehicle_id\nWHERE COALESCE(f.last_fuel_date, '1900-01-01'::timestamp) < NOW() - 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.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.trips ( trip_id character varying(64) NOT NULL, route_id character varying(64), vehicle_id character varying(64) NOT NULL, driver_id character varying(64) NOT NULL, scheduled_departure timestamp with time zone NOT NULL, actual_departure timestamp with time zone, scheduled_arrival timestamp with time zone NOT NULL, actual_arrival timestamp with time zone, origin_location_id character varying(64) NOT NULL, destination_location_id character varying(64) NOT NULL, status character varying(32) NOT NULL, passenger_count integer, cargo_manifest_id character varying(64), PRIMARY KEY (trip_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.fuel_logs ( fuel_log_id character varying(64) NOT NULL, vehicle_id character varying(64) NOT NULL, trip_id character varying(64), log_timestamp timestamp with time zone NOT NULL, fuel_type character varying(32) NOT NULL, quantity numeric(10, 3) NOT NULL, unit character varying(16) NOT NULL, cost_per_unit numeric(8, 4), total_cost numeric(10, 2) NOT NULL, odometer_reading integer, location_id character varying(64), PRIMARY KEY (fuel_log_id) )\nCREATE TABLE transportation.passengers ( passenger_id character varying(64) NOT NULL, first_name character varying(128) NOT NULL, last_name character varying(128) NOT NULL, email character varying(128) UNIQUE, phone_number character varying(32) UNIQUE, date_of_birth date, loyalty_program_id character varying(64), created_at timestamp with time zone NOT NULL, PRIMARY KEY (passenger_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": "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": "List users who have received notifications triggered by another user (non-system notifications). Show the recipient username, notification type, and the sender username."}, {"role": "assistant", "content": "SELECT T1.username AS recipient_username, T2.notification_type, T3.username AS sender_username FROM social_media.users AS T1 JOIN social_media.notifications AS T2 ON T1.user_id = T2.recipient_user_id JOIN social_media.users AS T3 ON T2.sender_user_id = T3.user_id;"}, {"role": "user", "content": "Refine the list from Turn 1 to only include notifications of type 'follow' or 'mention'."}, {"role": "assistant", "content": "SELECT T1.username AS recipient_username, T2.notification_type, T3.username AS sender_username FROM social_media.users AS T1 JOIN social_media.notifications AS T2 ON T1.user_id = T2.recipient_user_id JOIN social_media.users AS T3 ON T2.sender_user_id = T3.user_id WHERE T2.notification_type IN ('follow', 'mention');"}, {"role": "user", "content": "Further filter to only include notifications created in 2024 and order the results by notification creation time descending."}, {"role": "assistant", "content": "SELECT T1.username AS recipient_username, T2.notification_type, T3.username AS sender_username FROM social_media.users AS T1 JOIN social_media.notifications AS T2 ON T1.user_id = T2.recipient_user_id JOIN social_media.users AS T3 ON T2.sender_user_id = T3.user_id WHERE T2.notification_type IN ('follow', 'mention') AND EXTRACT(YEAR FROM T2.created_at) = 2024 ORDER BY T2.created_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 social_media.users (\n    user_id character varying(64) NOT NULL,  -- unique identifier for the user\n    username character varying(50) NOT NULL UNIQUE, -- user's unique handle\n    email character varying(128) NOT NULL UNIQUE, -- user's email address\n    password_hash text NOT NULL, -- hashed password\n    full_name character varying(100), -- user's full name\n    profile_picture_url text, -- URL to the profile picture\n    bio text, -- short user biography\n    location character varying(100), -- user's location\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of account creation\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last profile update\n    is_verified boolean NOT NULL DEFAULT false, -- verification status\n    PRIMARY KEY (user_id)\n)\nCREATE TABLE social_media.posts (\n    post_id character varying(64) NOT NULL, -- unique identifier for the post\n    user_id character varying(64) NOT NULL, -- identifier of the user who created the post (FK to users.user_id)\n    content text, -- textual content of the post\n    media_url text, -- URL to attached media (image/video)\n    media_type character varying(20), -- type of media ('image', 'video', null)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of post creation\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last post edit\n    visibility character varying(20) NOT NULL DEFAULT 'public', -- visibility ('public', 'friends', 'private')\n    location_lat numeric(9,6), -- latitude of post location\n    location_lon numeric(9,6), -- longitude of post location\n    PRIMARY KEY (post_id)\n)\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 (\n    like_id character varying(64) NOT NULL, -- unique identifier for the like\n    user_id character varying(64) NOT NULL, -- identifier of the user who liked (FK to users.user_id)\n    post_id character varying(64), -- identifier of the post being liked (FK to posts.post_id, nullable)\n    comment_id character varying(64), -- identifier of the comment being liked (FK to comments.comment_id, nullable)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of when the like occurred\n    PRIMARY KEY (like_id),\n    CONSTRAINT unique_user_like UNIQUE (user_id, post_id, comment_id), -- prevent duplicate likes\n    CONSTRAINT check_like_target CHECK (post_id IS NOT NULL OR comment_id IS NOT NULL) -- ensure it likes something\n)\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 (\n    hashtag_id character varying(64) NOT NULL, -- unique identifier for the hashtag\n    tag_name character varying(100) NOT NULL UNIQUE, -- the actual hashtag text (without '#')\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when the hashtag was first used\n    PRIMARY KEY (hashtag_id)\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 (\n    conversation_id character varying(64) NOT NULL, -- unique identifier for the conversation\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when conversation was initiated\n    last_message_at timestamp, -- timestamp of the last message in the conversation\n    is_group_chat boolean NOT NULL DEFAULT false, -- indicates if it's a group chat or direct message\n    group_name character varying(100), -- name of the group chat (if applicable)\n    PRIMARY KEY (conversation_id)\n)\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 (\n    setting_id character varying(64) NOT NULL, -- unique identifier for the setting entry\n    user_id character varying(64) NOT NULL UNIQUE, -- user the settings belong to (FK to users.user_id)\n    theme character varying(20) DEFAULT 'light', -- UI theme ('light', 'dark')\n    email_notifications_enabled boolean DEFAULT true, -- enable/disable email notifications\n    push_notifications_enabled boolean DEFAULT true, -- enable/disable push notifications\n    private_profile boolean DEFAULT false, -- is the user profile private\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last setting change\n    PRIMARY KEY (setting_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show the full name and contact email of citizens who have submitted at least one application for services that are currently inactive."}, {"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.applications a ON c.citizen_id = a.citizen_id\nJOIN government_services.services s ON a.service_id = s.service_id\nWHERE s.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.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.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, 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 (\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.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": "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": "List the first and last names of employees and the number of services offered by their agency."}, {"role": "assistant", "content": "SELECT e.first_name, e.last_name, COUNT(s.service_id) AS service_count\nFROM government_services.employees e\nLEFT JOIN government_services.services s ON e.agency_id = s.agency_id\nGROUP BY e.employee_id, e.first_name, e.last_name;"}, {"role": "user", "content": "Include only employees whose agency offers more than 3 services."}, {"role": "assistant", "content": "SELECT e.first_name, e.last_name, COUNT(s.service_id) AS service_count\nFROM government_services.employees e\nLEFT JOIN government_services.services s ON e.agency_id = s.agency_id\nGROUP BY e.employee_id, e.first_name, e.last_name\nHAVING COUNT(s.service_id) > 3;"}, {"role": "user", "content": "Add the agency name to the result."}, {"role": "assistant", "content": "SELECT e.first_name, e.last_name, ag.agency_name, COUNT(s.service_id) AS service_count\nFROM government_services.employees e\nJOIN government_services.agencies ag ON e.agency_id = ag.agency_id\nLEFT JOIN government_services.services s ON e.agency_id = s.agency_id\nGROUP BY e.employee_id, e.first_name, e.last_name, ag.agency_name\nHAVING COUNT(s.service_id) > 3;"}, {"role": "user", "content": "Now, only show services that are currently active in the count."}, {"role": "assistant", "content": "SELECT e.first_name, e.last_name, ag.agency_name, COUNT(s.service_id) AS active_service_count\nFROM government_services.employees e\nJOIN government_services.agencies ag ON e.agency_id = ag.agency_id\nLEFT JOIN 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, ag.agency_name\nHAVING COUNT(s.service_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 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 (\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.applications (\n    application_id character varying(64) NOT NULL, -- unique identifier for the application\n    citizen_id character varying(64) NOT NULL, -- FK to citizens table\n    service_id character varying(64) NOT NULL, -- FK to services table\n    submitted_at timestamp NOT NULL, -- time the application was submitted\n    status character varying(50) NOT NULL, -- e.g., Submitted, Processing, Approved, Rejected, Pending Info\n    last_updated_at timestamp NOT NULL, -- time the status or details last changed\n    assigned_employee_id character varying(64), -- FK to employees table (optional)\n    decision_date date, -- date when a final decision was made\n    notes text, -- internal notes or citizen-provided comments\n    reference_number character varying(100) UNIQUE, -- publicly visible reference number\n    PRIMARY KEY (application_id)\n)\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.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.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": "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 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": "Get the number of direct reports for each manager, showing manager_id and report_count."}, {"role": "assistant", "content": "SELECT manager_id,\n       COUNT(*) AS report_count\nFROM hospitality_technology.staff\nWHERE manager_id IS NOT NULL\nGROUP BY manager_id;"}, {"role": "user", "content": "Exclude managers who have fewer than 2 direct reports."}, {"role": "assistant", "content": "SELECT manager_id,\n       COUNT(*) AS report_count\nFROM hospitality_technology.staff\nWHERE manager_id IS NOT NULL\nGROUP BY manager_id\nHAVING COUNT(*) >= 2;"}, {"role": "user", "content": "Also include the manager's full name alongside their ID."}, {"role": "assistant", "content": "SELECT m.staff_id AS manager_id,\n       m.first_name || ' ' || m.last_name AS manager_full_name,\n       COUNT(s.staff_id) AS report_count\nFROM hospitality_technology.staff s\nJOIN hospitality_technology.staff m\n  ON s.manager_id = m.staff_id\nGROUP BY m.staff_id, m.first_name, m.last_name\nHAVING COUNT(s.staff_id) >= 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 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) )\n"}
{"conversations": [{"role": "user", "content": "Show the full names and contact emails of all citizens who have applied for services with a standard fee greater than 100."}, {"role": "assistant", "content": "SELECT c.first_name || ' ' || c.last_name AS full_name, c.contact_email\nFROM government_services.citizens c\nJOIN government_services.services s ON c.citizen_id IS NOT NULL -- Replace with actual application linking table if exists\nWHERE s.standard_fee > 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 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": "For each user, show their username and how many unique conversations they have sent at least one message in where the conversation is a group chat."}, {"role": "assistant", "content": "SELECT u.username, COUNT(DISTINCT m.conversation_id) AS group_chats_messaged_in\nFROM social_media.users u\nJOIN social_media.messages m ON u.user_id = m.sender_user_id\nJOIN social_media.conversations c ON m.conversation_id = c.conversation_id\nWHERE c.is_group_chat = TRUE\nGROUP BY u.username;"}, {"role": "user", "content": "Instead, show only users who have sent messages in more than one group chat, and include their email addresses."}, {"role": "assistant", "content": "SELECT u.username, u.email, COUNT(DISTINCT m.conversation_id) AS group_chats_messaged_in\nFROM social_media.users u\nJOIN social_media.messages m ON u.user_id = m.sender_user_id\nJOIN social_media.conversations c ON m.conversation_id = c.conversation_id\nWHERE c.is_group_chat = TRUE\nGROUP BY u.username, u.email\nHAVING COUNT(DISTINCT m.conversation_id) > 1;"}, {"role": "user", "content": "Also add the most recent message time sent by each user in these group chats."}, {"role": "assistant", "content": "SELECT u.username, u.email, COUNT(DISTINCT m.conversation_id) AS group_chats_messaged_in, MAX(m.sent_at) AS last_message_time\nFROM social_media.users u\nJOIN social_media.messages m ON u.user_id = m.sender_user_id\nJOIN social_media.conversations c ON m.conversation_id = c.conversation_id\nWHERE c.is_group_chat = TRUE\nGROUP BY u.username, u.email\nHAVING COUNT(DISTINCT m.conversation_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 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 (\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.follows ( follow_id character varying(64) NOT NULL, follower_user_id character varying(64) NOT NULL, following_user_id character varying(64) NOT NULL, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (follow_id), CONSTRAINT unique_follow UNIQUE (follower_user_id, following_user_id) )\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 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.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 ( 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 )\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": "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": "Show me the user ID, wallet address, and transaction ID for the first 20 transactions sent from any user's wallet."}, {"role": "assistant", "content": "SELECT W.user_id, W.address, T.transaction_id FROM web3.wallets W JOIN web3.transactions T ON W.address = T.from_address LIMIT 20;"}, {"role": "user", "content": "Instead of listing individual transactions, please count how many transactions have originated from each user's wallets."}, {"role": "assistant", "content": "SELECT W.user_id, COUNT(T.transaction_id) FROM web3.wallets W JOIN web3.transactions T ON W.address = T.from_address GROUP BY W.user_id;"}, {"role": "user", "content": "Can you filter this list to only show users who have originated more than 100 transactions?"}, {"role": "assistant", "content": "SELECT W.user_id, COUNT(T.transaction_id) FROM web3.wallets W JOIN web3.transactions T ON W.address = T.from_address GROUP BY W.user_id HAVING COUNT(T.transaction_id) > 100;"}, {"role": "user", "content": "Please sort the results by the transaction count in descending order."}, {"role": "assistant", "content": "SELECT W.user_id, COUNT(T.transaction_id) FROM web3.wallets W JOIN web3.transactions T ON W.address = T.from_address GROUP BY W.user_id HAVING COUNT(T.transaction_id) > 100 ORDER BY COUNT(T.transaction_id) 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\nCREATE TABLE web3.transactions ( transaction_id text PRIMARY KEY, from_address text, to_address text, value numeric, gas_used int, gas_price numeric, block_number int, timestamp timestamp, input_data text, status text, nonce int )\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": "List all peer logs, showing the user_id and the action taken, ordered by the most recent log entry."}, {"role": "assistant", "content": "SELECT user_id, action, logged_at\nFROM trading_platform.logs\nORDER BY logged_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 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.assets ( asset_id text, name text, symbol text, type text )\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, name text, description text, url text )\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": "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 me the top 3 smart money addresses by profit across all chains, along with their most profitable token and chain information."}, {"role": "assistant", "content": "SELECT address, profit, most_profit_token, chain\nFROM smart_money_profit\nORDER BY profit DESC\nLIMIT 3;"}, {"role": "user", "content": "Actually, I only want to see addresses from Ethereum chain with ROI over 30%."}, {"role": "assistant", "content": "SELECT address, profit, most_profit_token, roi\nFROM smart_money_profit\nWHERE chain = 'Ethereum' AND roi > 30\nORDER BY profit DESC\nLIMIT 3;"}, {"role": "user", "content": "Can you add their realized profit ratio and filter to only show results with profit over $100,000?"}, {"role": "assistant", "content": "SELECT address, profit, most_profit_token, roi, realized_ratio\nFROM smart_money_profit\nWHERE chain = 'Ethereum' AND roi > 30 AND profit > 100000\nORDER BY profit DESC\nLIMIT 3;"}, {"role": "user", "content": "Now order these results by ROI in descending order instead of profit."}, {"role": "assistant", "content": "SELECT address, profit, most_profit_token, roi, realized_ratio\nFROM smart_money_profit\nWHERE chain = 'Ethereum' AND roi > 30 AND profit > 100000\nORDER BY roi DESC\nLIMIT 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 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 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 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 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": "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": "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": "Show the name, symbol, and type of each asset, along with the total number of orders placed for each asset."}, {"role": "assistant", "content": "SELECT a.name, a.symbol, a.type, COUNT(o.order_id) AS order_count\nFROM trading_platform.assets a\nLEFT JOIN trading_platform.orders o ON a.asset_id = o.asset_id\nGROUP BY a.asset_id, a.name, a.symbol, a.type;"}, {"role": "user", "content": "Only include assets that have at least 10 orders, and order the result by order_count descending."}, {"role": "assistant", "content": "SELECT a.name, a.symbol, a.type, COUNT(o.order_id) AS order_count\nFROM trading_platform.assets a\nLEFT JOIN trading_platform.orders o ON a.asset_id = o.asset_id\nGROUP BY a.asset_id, a.name, a.symbol, a.type\nHAVING COUNT(o.order_id) >= 10\nORDER BY order_count DESC;"}, {"role": "user", "content": "Instead of all orders, only consider orders with status 'open'."}, {"role": "assistant", "content": "SELECT a.name, a.symbol, a.type, COUNT(o.order_id) AS open_order_count\nFROM trading_platform.assets a\nLEFT JOIN trading_platform.orders o ON a.asset_id = o.asset_id AND o.status = 'open'\nGROUP BY a.asset_id, a.name, a.symbol, a.type\nHAVING COUNT(o.order_id) >= 10\nORDER BY open_order_count DESC;"}, {"role": "user", "content": "The SQL doesn't work because some assets have no open orders, but I want to include those assets with a count of 0. Please update the query accordingly."}, {"role": "assistant", "content": "SELECT a.name, a.symbol, a.type, COUNT(o.order_id) AS open_order_count\nFROM trading_platform.assets a\nLEFT JOIN trading_platform.orders o ON a.asset_id = o.asset_id AND o.status = 'open'\nGROUP BY a.asset_id, a.name, a.symbol, a.type\nHAVING COUNT(o.order_id) >= 10 OR COUNT(o.order_id) = 0\nORDER BY open_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 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 (\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, name text, symbol text, type text )\nCREATE TABLE trading_platform.dapps ( dapp_id text PRIMARY KEY, name text, description text, url text )\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)\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 the first and last name of each citizen along with the city and state of the service location for their agency."}, {"role": "assistant", "content": "SELECT c.first_name, c.last_name, sl.city, sl.state\nFROM government_services.citizens c\nJOIN government_services.payments p ON c.citizen_id = p.citizen_id\nJOIN government_services.employees e ON p.application_id IS NOT NULL AND e.agency_id IS NOT NULL\nJOIN government_services.service_locations sl ON e.agency_id = sl.agency_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.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.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": "Get a count of available rooms per room type across all properties."}, {"role": "assistant", "content": "SELECT T2.type_name, COUNT(T1.room_id) AS available_room_count FROM hospitality_technology.rooms AS T1 INNER JOIN hospitality_technology.room_types AS T2 ON T1.room_type_id = T2.room_type_id WHERE T1.status = 'Available' GROUP BY T2.room_type_id, T2.type_name;"}, {"role": "user", "content": "Filter the results to only include room types with more than 50 available rooms. Also include the average base rate for these types."}, {"role": "assistant", "content": "SELECT T2.type_name, COUNT(T1.room_id) AS available_room_count, AVG(T2.base_rate) AS average_base_rate FROM hospitality_technology.rooms AS T1 INNER JOIN hospitality_technology.room_types AS T2 ON T1.room_type_id = T2.room_type_id WHERE T1.status = 'Available' GROUP BY T2.room_type_id, T2.type_name HAVING COUNT(T1.room_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 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 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.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.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.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.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.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.payments ( payment_id character varying(64) NOT NULL, reservation_id character varying(64), guest_id character varying(64) NOT NULL, bill_id character varying(64), amount numeric(12,2) NOT NULL, currency_code character varying(3) NOT NULL, payment_method character varying(50) NOT NULL, card_type character varying(50), card_last_four character varying(4), transaction_ref character varying(128), payment_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, status character varying(50) NOT NULL, staff_id_processed character varying(64), notes text, PRIMARY KEY (payment_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (staff_id_processed) REFERENCES hospitality_technology.staff(staff_id) )\n"}
{"conversations": [{"role": "user", "content": "List the full names and email addresses of staff members who have delivered at least one service order in the past 30 days, along with the count of orders they delivered. Sort by count descending."}, {"role": "assistant", "content": "SELECT st.staff_id,\n       st.first_name || ' ' || st.last_name AS full_name,\n       st.work_email,\n       COUNT(so.order_id) AS delivered_count\nFROM hospitality_technology.staff st\nJOIN hospitality_technology.service_orders so\n  ON st.staff_id = so.staff_id_delivered\nWHERE so.status = 'Delivered'\n  AND so.delivery_timestamp >= CURRENT_DATE - INTERVAL '30 days'\nGROUP BY st.staff_id, st.first_name, st.last_name, st.work_email\nORDER BY delivered_count DESC;"}, {"role": "user", "content": "Actually, only include staff who delivered more than 5 orders in that period."}, {"role": "assistant", "content": "SELECT st.staff_id,\n       st.first_name || ' ' || st.last_name AS full_name,\n       st.work_email,\n       COUNT(so.order_id) AS delivered_count\nFROM hospitality_technology.staff st\nJOIN hospitality_technology.service_orders so\n  ON st.staff_id = so.staff_id_delivered\nWHERE so.status = 'Delivered'\n  AND so.delivery_timestamp >= CURRENT_DATE - INTERVAL '30 days'\nGROUP BY st.staff_id, st.first_name, st.last_name, st.work_email\nHAVING COUNT(so.order_id) > 5\nORDER BY delivered_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 ( 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.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 )\n"}
{"conversations": [{"role": "user", "content": "Show me all invoices where the amount paid is exactly equal to the total amount."}, {"role": "assistant", "content": "SELECT * FROM legal_services.invoices WHERE amount_paid = total_amount;"}, {"role": "user", "content": "Instead, show only the invoice_number, client_id, and payment_date for these invoices, and sort by payment_date descending."}, {"role": "assistant", "content": "SELECT invoice_number, client_id, payment_date FROM legal_services.invoices WHERE amount_paid = total_amount ORDER BY payment_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 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)\n"}
{"conversations": [{"role": "user", "content": "Show me all customers (customer_id, first_name, last_name) who have made trades in the last 30 days, along with the total trade amount for each customer, sorted by total trade amount in descending order."}, {"role": "assistant", "content": "SELECT c.customer_id, c.first_name, c.last_name, SUM(t.total_amount) AS total_trade_amount FROM financial_services.customers c JOIN financial_services.accounts a ON c.customer_id = a.customer_id JOIN financial_services.trades t ON a.account_id = t.account_id WHERE t.trade_timestamp >= CURRENT_DATE - INTERVAL '30 days' GROUP BY c.customer_id, c.first_name, c.last_name ORDER BY total_trade_amount DESC;"}, {"role": "user", "content": "Now modify the query to only include trades executed on the 'NYSE' venue and include the trade count for each customer."}, {"role": "assistant", "content": "SELECT c.customer_id, c.first_name, c.last_name, SUM(t.total_amount) AS total_trade_amount, COUNT(t.trade_id) AS trade_count FROM financial_services.customers c JOIN financial_services.accounts a ON c.customer_id = a.customer_id JOIN financial_services.trades t ON a.account_id = t.account_id WHERE t.trade_timestamp >= CURRENT_DATE - INTERVAL '30 days' AND t.execution_venue = 'NYSE' GROUP BY c.customer_id, c.first_name, c.last_name ORDER BY total_trade_amount 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.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 text NOT NULL, -- customer's primary address\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,\n    email character varying(128) UNIQUE, -- customer's email address\n    phone_number character varying(32),\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of customer record creation\n    status character varying(32) NOT NULL, -- e.g., Active, Inactive, Pending Verification\n    risk_profile character varying(50), -- e.g., Low, Medium, High\n    PRIMARY KEY (customer_id)\n)\nCREATE TABLE financial_services.securities (\n    security_id character varying(64) NOT NULL, -- unique identifier for the security\n    ticker_symbol character varying(20) NOT NULL UNIQUE, -- stock ticker or fund symbol\n    isin_code character varying(12) UNIQUE, -- International Securities Identification Number\n    cusip_code character varying(9) UNIQUE, -- CUSIP number\n    security_name text NOT NULL, -- full name of the security\n    security_type character varying(50) NOT NULL, -- e.g., Stock, Bond, ETF, Mutual Fund, Option, Future\n    exchange character varying(50), -- primary exchange where traded (e.g., NYSE, NASDAQ)\n    currency character varying(3) NOT NULL, -- currency the security is denominated in\n    issuer_name character varying(255), -- name of the issuing entity\n    sector character varying(100), -- industry sector\n    last_updated timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,\n    PRIMARY KEY (security_id)\n)\nCREATE TABLE financial_services.trades (\n    trade_id character varying(64) NOT NULL, -- unique identifier for the trade\n    account_id character varying(64) NOT NULL, -- investment account executing the trade\n    security_id character varying(64) NOT NULL, -- security being traded\n    order_id character varying(64), -- related order ID if applicable\n    trade_type character varying(10) NOT NULL, -- 'Buy' or 'Sell'\n    quantity numeric(19, 8) NOT NULL, -- number of units traded\n    price_per_unit numeric(19, 8) NOT NULL, -- price per unit of the security\n    total_amount numeric(19, 4) NOT NULL, -- total value of the trade (quantity * price)\n    commission numeric(10, 4), -- commission fee charged for the trade\n    trade_timestamp timestamp NOT NULL, -- exact time the trade was executed\n    settlement_date date, -- date the trade settles\n    status character varying(32) NOT NULL, -- e.g., Executed, Settled, Cancelled\n    execution_venue character varying(100), -- where the trade was executed\n    PRIMARY KEY (trade_id),\n    FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id),\n    FOREIGN KEY (security_id) REFERENCES financial_services.securities(security_id)\n)\nCREATE TABLE financial_services.market_data (\n    data_point_id bigserial NOT NULL, -- auto-incrementing primary key\n    security_id character varying(64) NOT NULL, -- identifier for the security\n    data_timestamp timestamp NOT NULL, -- timestamp for the data point (e.g., end of day, intraday)\n    open_price numeric(19, 8), -- opening price for the period\n    high_price numeric(19, 8), -- highest price during the period\n    low_price numeric(19, 8), -- lowest price during the period\n    close_price numeric(19, 8) NOT NULL, -- closing price for the period\n    adjusted_close_price numeric(19, 8), -- closing price adjusted for dividends and splits\n    volume bigint, -- trading volume during the period\n    source character varying(50), -- source of the market data (e.g., Bloomberg, Refinitiv)\n    PRIMARY KEY (data_point_id),\n    UNIQUE (security_id, data_timestamp), -- Ensure unique data point per security per time\n    FOREIGN KEY (security_id) REFERENCES financial_services.securities(security_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": "Show me, for each item, the total number of times it has been acquired and the earliest date it was acquired. Also, show the number of unique players who have acquired each item."}, {"role": "assistant", "content": "SELECT item_id, COUNT(*) AS total_acquisitions, MIN(acquired_at) AS earliest_acquired, COUNT(DISTINCT player_id) AS unique_players FROM gaming_technology.player_inventory GROUP BY item_id;"}, {"role": "user", "content": "Now, could you limit the results to only items that have been acquired by at least 3 unique players?"}, {"role": "assistant", "content": "SELECT item_id, COUNT(*) AS total_acquisitions, MIN(acquired_at) AS earliest_acquired, COUNT(DISTINCT player_id) AS unique_players FROM gaming_technology.player_inventory GROUP BY item_id HAVING COUNT(DISTINCT player_id) >= 3;"}, {"role": "user", "content": "Also, sort the results by total_acquisitions in descending order."}, {"role": "assistant", "content": "SELECT item_id, COUNT(*) AS total_acquisitions, MIN(acquired_at) AS earliest_acquired, COUNT(DISTINCT player_id) AS unique_players FROM gaming_technology.player_inventory GROUP BY item_id HAVING COUNT(DISTINCT player_id) >= 3 ORDER BY total_acquisitions DESC;"}, {"role": "user", "content": "Finally, limit the output to the top 5 items."}, {"role": "assistant", "content": "SELECT item_id, COUNT(*) AS total_acquisitions, MIN(acquired_at) AS earliest_acquired, COUNT(DISTINCT player_id) AS unique_players FROM gaming_technology.player_inventory GROUP BY item_id HAVING COUNT(DISTINCT player_id) >= 3 ORDER BY total_acquisitions 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 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": "What is the average difficulty and the maximum nonce value for all blocks recorded?"}, {"role": "assistant", "content": "SELECT AVG(difficulty), MAX(nonce) FROM blockchain.blocks"}], "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 blockchain.blocks ( block_id text, previous_block_id text, timestamp timestamp, nonce integer, merkle_root text, difficulty integer )\n"}
{"conversations": [{"role": "user", "content": "Find all patients who have been prescribed medications with dosage greater than 50mg, along with their medication details and prescribing doctor's name."}, {"role": "assistant", "content": "SELECT p.patient_id, p.first_name, p.last_name, pr.dosage, pr.medication_id, pr.start_date, doc.first_name AS doctor_first_name, doc.last_name AS doctor_last_name FROM healthcare.patients p JOIN healthcare.prescriptions pr ON p.patient_id = pr.patient_id JOIN healthcare.doctors doc ON pr.doctor_id = doc.doctor_id WHERE CAST(SUBSTRING_INDEX(pr.dosage, 'mg', 1) AS UNSIGNED) > 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 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.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.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 )\n"}
{"conversations": [{"role": "user", "content": "Find the wallet address, user ID, and the contract address of any contract where that wallet is listed as the deployer."}, {"role": "assistant", "content": "SELECT w.address AS wallet_address, w.user_id, c.address AS contract_address\nFROM web3.wallets w\nJOIN web3.contracts c ON w.address = c.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) )\nCREATE TABLE web3.events ( event_id.text, contract_id.text, event_name.text, data.text, emitted_at.timestamp, transaction_id.text, log_index.integer )\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 (\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 text PRIMARY KEY, token_id text, from_address text, to_address text, value numeric, transaction_id text, log_index int )\nCREATE TABLE web3.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List each case_number along with the total number of documents associated with it."}, {"role": "assistant", "content": "SELECT c.case_number,\n       COUNT(d.document_id) AS document_count\nFROM legal_services.cases c\nJOIN legal_services.documents d\n  ON c.case_id = d.case_id\nGROUP BY c.case_number;"}, {"role": "user", "content": "Include cases that have no documents as well, displaying the document_count as zero."}, {"role": "assistant", "content": "SELECT c.case_number,\n       COUNT(d.document_id) AS document_count\nFROM legal_services.cases c\nLEFT JOIN legal_services.documents d\n  ON c.case_id = d.case_id\nGROUP BY c.case_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 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.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 )\n"}
{"conversations": [{"role": "user", "content": "List all medical record entries where the treatment_plan mentions a medication name. Return patient_id, record_id, and the matching medication_name."}, {"role": "assistant", "content": "SELECT mr.patient_id,\n       mr.record_id,\n       m.medication_name\nFROM healthcare.medical_records AS mr\nJOIN healthcare.medications AS m\n  ON mr.treatment_plan ILIKE '%' || m.medication_name || '%';"}, {"role": "user", "content": "Actually, only include medications manufactured by 'Pfizer'."}, {"role": "assistant", "content": "SELECT mr.patient_id,\n       mr.record_id,\n       m.medication_name\nFROM healthcare.medical_records AS mr\nJOIN healthcare.medications AS m\n  ON mr.treatment_plan ILIKE '%' || m.medication_name || '%'\nWHERE m.manufacturer = 'Pfizer';"}, {"role": "user", "content": "Also sort the results by record_date descending."}, {"role": "assistant", "content": "SELECT mr.patient_id,\n       mr.record_id,\n       m.medication_name\nFROM healthcare.medical_records AS mr\nJOIN healthcare.medications AS m\n  ON mr.treatment_plan ILIKE '%' || m.medication_name || '%'\nWHERE m.manufacturer = 'Pfizer'\nORDER BY mr.record_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.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.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.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.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": "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": "How many claims were reported in the last 90 days?"}, {"role": "assistant", "content": "SELECT COUNT(*) FROM claims WHERE reported_date >= 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 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.insurance_products ( product_id character varying(64) NOT NULL, product_name character varying(150) NOT NULL, product_type character varying(50) NOT NULL, description text, base_premium numeric(10, 2) NOT NULL, coverage_details text, underwriting_rules text, is_active boolean NOT NULL DEFAULT true, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at timestamp, PRIMARY KEY (product_id) )\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 )\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 )\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": "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": "Find the total number of documents uploaded by each citizen along with their first and last names."}, {"role": "assistant", "content": "SELECT c.citizen_id, c.first_name, c.last_name, COUNT(d.document_id) AS document_count\nFROM government_services.citizens c\nLEFT JOIN government_services.documents d ON c.citizen_id = d.citizen_id\nGROUP BY c.citizen_id, c.first_name, c.last_name;"}, {"role": "user", "content": "Actually, I only want to include those citizens who have uploaded documents in the last 30 days."}, {"role": "assistant", "content": "SELECT c.citizen_id, c.first_name, c.last_name, COUNT(d.document_id) AS document_count\nFROM government_services.citizens c\nJOIN government_services.documents d ON c.citizen_id = d.citizen_id\nWHERE d.upload_timestamp >= NOW() - INTERVAL '30 days'\nGROUP BY c.citizen_id, c.first_name, c.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 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.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.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, 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.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": "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": "For each address, show the total amount contained in UTXOs that have been spent."}, {"role": "assistant", "content": "SELECT address, SUM(amount) FROM utxos WHERE spent = TRUE GROUP BY address;"}, {"role": "user", "content": "Only include addresses where this total spent amount is greater than 500 and order the results by the total amount descending."}, {"role": "assistant", "content": "SELECT address, SUM(amount) FROM utxos WHERE spent = TRUE GROUP BY address HAVING SUM(amount) > 500 ORDER BY SUM(amount) 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 (\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)\n"}
{"conversations": [{"role": "user", "content": "Display each product alongside the most recently updated product of the same type. Return original_id, original_updated_at, recent_id, recent_updated_at, and product_type."}, {"role": "assistant", "content": "SELECT p.product_id AS original_id, p.updated_at AS original_updated_at, r.product_id AS recent_id, r.updated_at AS recent_updated_at, p.product_type FROM insurance.insurance_products p JOIN (SELECT product_type, MAX(updated_at) AS max_updated FROM insurance.insurance_products GROUP BY product_type) m ON p.product_type = m.product_type JOIN insurance.insurance_products r ON r.product_type = p.product_type AND r.updated_at = m.max_updated;"}, {"role": "user", "content": "Actually, exclude entries where original or recent updated_at is null."}, {"role": "assistant", "content": "SELECT p.product_id AS original_id, p.updated_at AS original_updated_at, r.product_id AS recent_id, r.updated_at AS recent_updated_at, p.product_type FROM insurance.insurance_products p JOIN (SELECT product_type, MAX(updated_at) AS max_updated FROM insurance.insurance_products WHERE updated_at IS NOT NULL GROUP BY product_type) m ON p.product_type = m.product_type AND p.updated_at IS NOT NULL JOIN insurance.insurance_products r ON r.product_type = p.product_type AND r.updated_at = m.max_updated;"}, {"role": "user", "content": "Also, only include product types that have more than 2 products."}, {"role": "assistant", "content": "SELECT p.product_id AS original_id, p.updated_at AS original_updated_at, r.product_id AS recent_id, r.updated_at AS recent_updated_at, p.product_type FROM insurance.insurance_products p JOIN (SELECT product_type, MAX(updated_at) AS max_updated FROM insurance.insurance_products WHERE updated_at IS NOT NULL GROUP BY product_type) m ON p.product_type = m.product_type AND p.updated_at IS NOT NULL JOIN insurance.insurance_products r ON r.product_type = p.product_type AND r.updated_at = m.max_updated WHERE p.product_type IN (SELECT product_type FROM insurance.insurance_products GROUP BY product_type HAVING COUNT(*) > 2);"}, {"role": "user", "content": "Finally, sort the results by recent_updated_at descending."}, {"role": "assistant", "content": "SELECT p.product_id AS original_id, p.updated_at AS original_updated_at, r.product_id AS recent_id, r.updated_at AS recent_updated_at, p.product_type FROM insurance.insurance_products p JOIN (SELECT product_type, MAX(updated_at) AS max_updated FROM insurance.insurance_products WHERE updated_at IS NOT NULL GROUP BY product_type) m ON p.product_type = m.product_type AND p.updated_at IS NOT NULL JOIN insurance.insurance_products r ON r.product_type = p.product_type AND r.updated_at = m.max_updated WHERE p.product_type IN (SELECT product_type FROM insurance.insurance_products GROUP BY product_type HAVING COUNT(*) > 2) ORDER BY recent_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.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": "What is the total sum of all amounts for all UTXOs in the system, regardless of whether they are spent or unspent?"}, {"role": "assistant", "content": "SELECT SUM(amount) FROM trading_platform.utxos"}], "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.trades ( trade_id text PRIMARY KEY, order_id text, buyer_id text, seller_id text, asset_id text, quantity numeric, price numeric, traded_at timestamp )\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.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 the names of service locations where services categorized as 'Licensing' have had appointments scheduled."}, {"role": "assistant", "content": "SELECT DISTINCT T1.location_name FROM service_locations AS T1 JOIN appointments AS T2 ON T1.location_id = T2.location_id JOIN services AS T3 ON T2.service_id = T3.service_id WHERE T3.category = 'Licensing';"}], "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 (\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)\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)\n"}
{"conversations": [{"role": "user", "content": "Find pairs of token transfers within the same transaction and for the same token, where the value of one transfer is exactly twice the value of the other. Show the transaction ID, token ID, and both transfer IDs and their values."}, {"role": "assistant", "content": "SELECT\n  t1.transaction_id,\n  t1.token_id,\n  t1.transfer_id AS transfer_id_1,\n  t1.value AS value_1,\n  t2.transfer_id AS transfer_id_2,\n  t2.value AS value_2\nFROM web3.token_transfers AS t1\nJOIN web3.token_transfers AS t2\n  ON t1.transaction_id = t2.transaction_id\n  AND t1.token_id = t2.token_id\n  AND t1.transfer_id < t2.transfer_id\nWHERE\n  t1.value = 2 * t2.value\n  OR t2.value = 2 * t1.value;"}], "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.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)\n"}
{"conversations": [{"role": "user", "content": "Show all users whose full name starts with 'A' and who have updated their profile in June 2024. Please include their usernames and updated_at timestamps."}, {"role": "assistant", "content": "SELECT username, updated_at FROM social_media.users WHERE full_name ILIKE 'A%' AND EXTRACT(YEAR FROM updated_at) = 2024 AND EXTRACT(MONTH FROM updated_at) = 6;"}, {"role": "user", "content": "I also want to know which of them have a verified profile. Can you add the verification status to the results?"}, {"role": "assistant", "content": "SELECT username, updated_at, is_verified FROM social_media.users WHERE full_name ILIKE 'A%' AND EXTRACT(YEAR FROM updated_at) = 2024 AND EXTRACT(MONTH FROM updated_at) = 6;"}, {"role": "user", "content": "Now, please only show the users who are verified."}, {"role": "assistant", "content": "SELECT username, updated_at FROM social_media.users WHERE full_name ILIKE 'A%' AND EXTRACT(YEAR FROM updated_at) = 2024 AND EXTRACT(MONTH FROM updated_at) = 6 AND 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 )\n"}
{"conversations": [{"role": "user", "content": "Show all rooms that are on floor 3."}, {"role": "assistant", "content": "SELECT room_id, property_id, room_number FROM hospitality_technology.rooms WHERE floor = 3;"}, {"role": "user", "content": "For these rooms, include the property name and room number."}, {"role": "assistant", "content": "SELECT r.room_number, p.property_name FROM hospitality_technology.rooms AS r JOIN hospitality_technology.properties AS p ON r.property_id = p.property_id WHERE r.floor = 3;"}, {"role": "user", "content": "Also, include the type name and current status for each room."}, {"role": "assistant", "content": "SELECT r.room_number, p.property_name, rt.type_name, r.status FROM hospitality_technology.rooms AS r JOIN hospitality_technology.properties AS p ON r.property_id = p.property_id JOIN hospitality_technology.room_types AS rt ON r.room_type_id = rt.room_type_id AND r.property_id = rt.property_id WHERE r.floor = 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 hospitality_technology.properties ( property_id text, property_name text, address_line1 text, address_line2 text, city text, state_province text, postal_code text, country_code text, phone_number text, email_address text, property_type text, star_rating numeric, timezone text, manager_staff_id text, created_at timestamp, updated_at timestamp )\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.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 )\n"}
{"conversations": [{"role": "user", "content": "List all agencies that do not have a website URL specified. Return their agency_id, agency_name, and main_phone_number."}, {"role": "assistant", "content": "SELECT agency_id, agency_name, main_phone_number FROM government_services.agencies WHERE website_url IS NULL OR website_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 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) )\n"}
{"conversations": [{"role": "user", "content": "List all medical records, showing the record ID, record date, and the full name of the doctor who created the record. Include the patient ID as well."}, {"role": "assistant", "content": "SELECT mr.record_id, mr.record_date, mr.patient_id, d.first_name, d.last_name FROM healthcare.medical_records mr JOIN doctors d ON mr.doctor_id = d.doctor_id;"}, {"role": "user", "content": "Refine this to only include records where the chief_complaint is not null or empty and the doctor's specialty is 'Cardiology'."}, {"role": "assistant", "content": "SELECT mr.record_id, mr.record_date, mr.patient_id, d.first_name, d.last_name FROM healthcare.medical_records mr JOIN doctors d ON mr.doctor_id = d.doctor_id WHERE (mr.chief_complaint IS NOT NULL AND mr.chief_complaint != '') AND d.specialty = 'Cardiology';"}, {"role": "user", "content": "Also, sort the results by record_date in descending order and limit the output to the top 10 records."}, {"role": "assistant", "content": "SELECT mr.record_id, mr.record_date, mr.patient_id, d.first_name, d.last_name FROM healthcare.medical_records mr JOIN doctors d ON mr.doctor_id = d.doctor_id WHERE (mr.chief_complaint IS NOT NULL AND mr.chief_complaint != '') AND d.specialty = 'Cardiology' ORDER BY mr.record_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 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": "Could you list the player_id of users who have unlocked both achievement '11111111-1111-1111-1111-111111111111' and '22222222-2222-2222-2222-222222222222'?"}, {"role": "assistant", "content": "SELECT pa1.player_id\nFROM gaming_technology.player_achievements pa1\nJOIN gaming_technology.player_achievements pa2\n  ON pa1.player_id = pa2.player_id\nWHERE pa1.achievement_id = '11111111-1111-1111-1111-111111111111'\n  AND pa2.achievement_id = '22222222-2222-2222-2222-222222222222'\nGROUP BY pa1.player_id;"}, {"role": "user", "content": "Now also include the date when each of these achievements was unlocked, labeled as unlocked_ach1 and unlocked_ach2."}, {"role": "assistant", "content": "SELECT pa1.player_id,\n       pa1.unlocked_at AS unlocked_ach1,\n       pa2.unlocked_at AS unlocked_ach2\nFROM gaming_technology.player_achievements pa1\nJOIN gaming_technology.player_achievements pa2\n  ON pa1.player_id = pa2.player_id\nWHERE pa1.achievement_id = '11111111-1111-1111-1111-111111111111'\n  AND pa2.achievement_id = '22222222-2222-2222-2222-222222222222'\nGROUP BY pa1.player_id, pa1.unlocked_at, pa2.unlocked_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 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) )\n"}
{"conversations": [{"role": "user", "content": "Show me all wallet addresses that belong to user_id 'U1001', along with their private keys."}, {"role": "assistant", "content": "SELECT address_id, private_key FROM blockchain.wallets WHERE user_id = 'U1001';"}, {"role": "user", "content": "Now join this with another table to show the count of transactions for each of these wallet addresses."}, {"role": "assistant", "content": "Note: The schema only includes the wallets table. Without a transactions table in the schema, this query cannot be executed. Please provide the transactions table structure if you need this analysis."}], "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": "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": "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 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": "For each vehicle, list its vehicle_id, license_plate, and any older vehicle of the same type (showing older_vehicle_id and older year)."}, {"role": "assistant", "content": "SELECT cur.vehicle_id,\n       cur.license_plate,\n       old.vehicle_id AS older_vehicle_id,\n       old.year       AS older_vehicle_year\nFROM transportation.vehicles cur\nJOIN transportation.vehicles old\n  ON cur.type = old.type\n AND old.year < cur.year\nORDER BY cur.vehicle_id, old.year 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.vehicles (\n    vehicle_id character varying(64) NOT NULL,  -- unique identifier for the vehicle\n    license_plate character varying(32) NOT NULL UNIQUE, -- vehicle license plate\n    vin character varying(17) UNIQUE, -- vehicle identification number\n    make character varying(64) NOT NULL, -- manufacturer of the vehicle\n    model character varying(64) NOT NULL, -- model of the vehicle\n    year integer NOT NULL, -- manufacturing year\n    type character varying(32) NOT NULL, -- type of vehicle (e.g., Bus, Train, Truck, Car, Van)\n    capacity integer, -- passenger or cargo capacity\n    fuel_type character varying(32) NOT NULL, -- e.g., Diesel, Gasoline, Electric, Hydrogen\n    status character varying(32) NOT NULL, -- e.g., Active, Maintenance, Decommissioned\n    depot_id character varying(64), -- identifier of the home depot/base\n    acquisition_date date, -- date the vehicle was acquired\n    PRIMARY KEY (vehicle_id)\n)\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": "Show me all doctors who have prescribed medications with a dosage greater than 200mg, along with their specialties and the count of such prescriptions per doctor."}, {"role": "assistant", "content": "SELECT d.doctor_id, d.first_name, d.last_name, d.specialty, COUNT(p.prescription_id) AS prescription_count FROM healthcare.doctors d JOIN healthcare.prescriptions p ON d.doctor_id = p.doctor_id WHERE CAST(SUBSTRING(p.dosage FROM '[0-9]+') AS INTEGER) > 200 GROUP BY d.doctor_id, d.first_name, d.last_name, d.specialty ORDER BY prescription_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.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.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.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.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 pairs of citizens who share the same email domain."}, {"role": "assistant", "content": "SELECT c1.first_name AS first1,\n       c1.last_name AS last1,\n       c2.first_name AS first2,\n       c2.last_name AS last2,\n       SPLIT_PART(c1.contact_email, '@', 2) AS domain\nFROM government_services.citizens c1\nJOIN government_services.citizens c2\n  ON SPLIT_PART(c1.contact_email, '@', 2) = SPLIT_PART(c2.contact_email, '@', 2)\n AND c1.citizen_id < c2.citizen_id\nWHERE c1.contact_email IS NOT NULL\n  AND c2.contact_email 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 (\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)\n"}
{"conversations": [{"role": "user", "content": "Show me each product_type along with the count of products for that type, but only include types where the average base_premium exceeds 500. Order the results by the product count in descending order."}, {"role": "assistant", "content": "SELECT product_type,\n       COUNT(*) AS product_count\nFROM insurance.insurance_products\nGROUP BY product_type\nHAVING AVG(base_premium) > 500\nORDER BY product_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 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 the total billable hours and total billed amount for each lawyer who worked on 'Civil Litigation' cases in 2023, sorted by billed amount descending."}, {"role": "assistant", "content": "SELECT te.lawyer_id,\n       SUM(te.hours_spent) AS total_billable_hours,\n       SUM(te.hours_spent * te.billing_rate) AS total_billed_amount\nFROM legal_services.time_entries te\nJOIN legal_services.cases c ON te.case_id = c.case_id\nWHERE te.is_billable = true\n  AND te.is_billed = true\n  AND c.case_type = 'Civil Litigation'\n  AND te.date_worked BETWEEN '2023-01-01' AND '2023-12-31'\nGROUP BY te.lawyer_id\nORDER BY total_billed_amount DESC;"}, {"role": "user", "content": "Actually, I'd like to include only those lawyers who have at least 10 billable entries in that period."}, {"role": "assistant", "content": "SELECT te.lawyer_id,\n       SUM(te.hours_spent) AS total_billable_hours,\n       SUM(te.hours_spent * te.billing_rate) AS total_billed_amount\nFROM legal_services.time_entries te\nJOIN legal_services.cases c ON te.case_id = c.case_id\nWHERE te.is_billable = true\n  AND te.is_billed = true\n  AND c.case_type = 'Civil Litigation'\n  AND te.date_worked BETWEEN '2023-01-01' AND '2023-12-31'\nGROUP BY te.lawyer_id\nHAVING COUNT(*) >= 10\nORDER BY total_billed_amount DESC;"}, {"role": "user", "content": "Also break down the report by case, listing each lawyer and case_number along with their billable hours and billed amount per case, sorted by billed amount descending."}, {"role": "assistant", "content": "SELECT te.lawyer_id,\n       c.case_number,\n       SUM(te.hours_spent) AS case_billable_hours,\n       SUM(te.hours_spent * te.billing_rate) AS case_billed_amount\nFROM legal_services.time_entries te\nJOIN legal_services.cases c ON te.case_id = c.case_id\nWHERE te.is_billable = true\n  AND te.is_billed = true\n  AND c.case_type = 'Civil Litigation'\n  AND te.date_worked BETWEEN '2023-01-01' AND '2023-12-31'\nGROUP BY te.lawyer_id, c.case_number\nORDER BY case_billed_amount 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.clients ( client_id text, first_name text, last_name text, company_name text, email text, phone text, address text, date_registered timestamp, status text )\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 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.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 all pairs of tokens (show token_id for both) that share the same contract address, excluding pairs where the token_id is the same."}, {"role": "assistant", "content": "SELECT t1.token_id AS token_id1, t2.token_id AS token_id2, t1.contract_address FROM web3.tokens AS t1 JOIN web3.tokens AS t2 ON t1.contract_address = t2.contract_address WHERE t1.token_id < t2.token_id;"}], "system": "You are an 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) )\n"}
{"conversations": [{"role": "user", "content": "Find all unique diagnosis codes that are associated with more than one doctor, and show how many doctors are linked to each code."}, {"role": "assistant", "content": "SELECT diagnosis_code, COUNT(DISTINCT doctor_id) AS doctor_count FROM healthcare.diagnoses GROUP BY diagnosis_code HAVING COUNT(DISTINCT doctor_id) > 1;"}, {"role": "user", "content": "Also, show only codes that are used after January 1st, 2023."}, {"role": "assistant", "content": "SELECT diagnosis_code, COUNT(DISTINCT doctor_id) AS doctor_count FROM healthcare.diagnoses WHERE diagnosis_date > '2023-01-01' GROUP BY diagnosis_code HAVING COUNT(DISTINCT doctor_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 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": "List all patients who have a current prescription that was prescribed by a doctor with a specialty of 'Endocrinology'. Show patient full name, prescription ID, medication name, and prescription date."}, {"role": "assistant", "content": "SELECT p.patient_id, p.first_name || ' ' || p.last_name AS full_name, pr.prescription_id, m.medication_name, pr.prescription_date\nFROM healthcare.prescriptions pr\nJOIN healthcare.medications m ON pr.medication_id = m.medication_id\nJOIN healthcare.patients p ON pr.patient_id = p.patient_id\nJOIN healthcare.doctors d ON pr.doctor_id = d.doctor_id\nWHERE d.specialty = 'Endocrinology' AND pr.end_date IS NULL OR pr.end_date > CURRENT_DATE;"}, {"role": "user", "content": "Include prescriptions that ended within the past 7 days as well."}, {"role": "assistant", "content": "SELECT p.patient_id, p.first_name || ' ' || p.last_name AS full_name, pr.prescription_id, m.medication_name, pr.prescription_date\nFROM healthcare.prescriptions pr\nJOIN healthcare.medications m ON pr.medication_id = m.medication_id\nJOIN healthcare.patients p ON pr.patient_id = p.patient_id\nJOIN healthcare.doctors d ON pr.doctor_id = d.doctor_id\nWHERE d.specialty = 'Endocrinology' AND (pr.end_date IS NULL OR pr.end_date > CURRENT_DATE OR pr.end_date >= CURRENT_DATE - INTERVAL '7 days');"}, {"role": "user", "content": "I got an error: relation \"healthcare.patients\" does not exist. Can you fix it using existing tables only?"}, {"role": "assistant", "content": "SELECT pr.patient_id, pr.prescription_id, m.medication_name, pr.prescription_date\nFROM healthcare.prescriptions pr\nJOIN healthcare.medications m ON pr.medication_id = m.medication_id\nJOIN healthcare.doctors d ON pr.doctor_id = d.doctor_id\nWHERE d.specialty = 'Endocrinology' AND (pr.end_date IS NULL OR pr.end_date > CURRENT_DATE OR pr.end_date >= 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 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": "Retrieve each agent's ID, full name, and the count of 'Pending' policies they have sold with a premium_amount greater than 2000. Order the results by the policy count descending."}, {"role": "assistant", "content": "SELECT a.agent_id,\n       a.first_name || ' ' || a.last_name AS agent_name,\n       COUNT(p.policy_id) AS pending_policy_count\nFROM insurance.agents a\nJOIN insurance.policies p ON a.agent_id = p.agent_id\nWHERE p.status = 'Pending'\n  AND p.premium_amount > 2000\nGROUP BY a.agent_id, agent_name\nORDER BY pending_policy_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 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.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": "能否帮我统计特定车站(station_id 为 'station_xyz')的所有工作人员数量？"}, {"role": "assistant", "content": "MATCH (s:Station {station_id: 'station_xyz'})<-[:BASED_AT]-(staff:Staff)\nRETURN COUNT(staff) AS total_staff"}], "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// Node Label: :Station\n// Properties:\n//   station_id: String (Constraint: UNIQUE)\n//   station_name: String\n//   city: String (Index recommended)\n//   state_province: String\n//   country_code: String\n//   address: String\n//   timezone: String\n//   number_of_platforms: Integer\n//   created_at: DateTime\n//   last_updated_at: DateTime\n// Example Cypher CREATE:\n// CREATE (:Station {station_id: 'station_xyz', station_name: 'Grand Central Terminal', city: 'New York', ...})\n// Node Label: :Platform\n// Properties:\n//   platform_id: String (Constraint: UNIQUE)\n//   platform_number: String\n//   track_number: String\n//   status: String\n//   length_meters: Float\n//   accessible: Boolean\n// Relationship: (:Platform)-[:LOCATED_AT]->(:Station)\n// Example Cypher CREATE:\n// MATCH (s:Station {station_id: 'station_xyz'})\n// CREATE (p:Platform {platform_id: 'plat_123', ...})-[:LOCATED_AT]->(s)\n// Node Label: :Train\n// Properties:\n//   train_id: String (Constraint: UNIQUE)\n//   train_number: String (Constraint: UNIQUE)\n//   model: String\n//   manufacturer: String\n//   year_manufactured: Integer\n//   capacity: Integer\n//   status: String\n//   last_maintenance_date: Date\n//   next_maintenance_date: Date\n// Example Cypher CREATE:\n// CREATE (:Train {train_id: 'train_789', train_number: 'Acela 2151', ...})\n// Node Label: :TrainCar\n// Properties:\n//   car_id: String (Constraint: UNIQUE)\n//   car_number: String\n//   car_type: String\n//   class: String\n//   capacity: Integer\n//   features: String (Or List<String> if driver supports)\n// Relationship: (:TrainCar)-[:PART_OF_TRAIN]->(:Train)\n// Example Cypher CREATE:\n// MATCH (t:Train {train_id: 'train_789'})\n// CREATE (c:TrainCar {car_id: 'car_abc', ...})-[:PART_OF_TRAIN]->(t)\n// Node Label: :Route\n// Properties:\n//   route_id: String (Constraint: UNIQUE)\n//   route_name: String\n//   description: String\n//   is_active: Boolean\n// Relationships:\n//   (:Route)-[:STARTS_AT]->(:Station)\n//   (:Route)-[:ENDS_AT]->(:Station)\n// Example Cypher CREATE:\n// MATCH (origin:Station {station_id: 'station_bos'}), (dest:Station {station_id: 'station_was'})\n// CREATE (r:Route {route_id: 'route_ne_corr', ...})-[:STARTS_AT]->(origin), (r)-[:ENDS_AT]->(dest)\n// Relationship: (:Route)-[rel:HAS_STOP]->(:Station)\n// Relationship Properties on :HAS_STOP:\n//   sequence_order: Integer\n//   distance_from_previous_km: Float\n//   typical_stop_duration_minutes: Integer\n// Example Cypher CREATE:\n// MATCH (r:Route {route_id: 'route_ne_corr'}), (s:Station {station_id: 'station_pvd'})\n// CREATE (r)-[:HAS_STOP {sequence_order: 2, distance_from_previous_km: 70.5, ...}]->(s)\n// Node Label: :ScheduledTrip (or just :Trip)\n// Properties:\n//   schedule_id: String (Constraint: UNIQUE)\n//   departure_datetime: DateTime\n//   arrival_datetime: DateTime\n//   status: String\n//   notes: String\n// Relationships:\n//   (:ScheduledTrip)-[:USES_TRAIN]->(:Train)\n//   (:ScheduledTrip)-[:FOLLOWS_ROUTE]->(:Route)\n// Example Cypher CREATE:\n// MATCH (t:Train {train_id: 'train_789'}), (r:Route {route_id: 'route_ne_corr'})\n// CREATE (sched:ScheduledTrip {schedule_id: 'sched_1122', ...})-[:USES_TRAIN]->(t), (sched)-[:FOLLOWS_ROUTE]->(r)\n// Relationship: (:ScheduledTrip)-[rel:SCHEDULED_STOP]->(:Station)\n// Relationship Properties on :SCHEDULED_STOP:\n//   sequence_order: Integer\n//   platform_id: String (references Platform node if modeled, or just store ID)\n//   scheduled_arrival_time: DateTime\n//   scheduled_departure_time: DateTime\n//   actual_arrival_time: DateTime\n//   actual_departure_time: DateTime\n//   status: String\n// Example Cypher CREATE:\n// MATCH (sched:ScheduledTrip {schedule_id: 'sched_1122'}), (s:Station {station_id: 'station_pvd'})\n// CREATE (sched)-[:SCHEDULED_STOP {sequence_order: 2, platform_id: 'plat_pvd_1', ...}]->(s)\n// Node Label: :Passenger\n// Properties:\n//   passenger_id: String (Constraint: UNIQUE)\n//   first_name: String\n//   last_name: String\n//   email: String (Constraint: UNIQUE, if not null)\n//   phone_number: String (Constraint: UNIQUE, if not null)\n//   date_of_birth: Date\n//   loyalty_program_id: String\n//   created_at: DateTime\n// Example Cypher CREATE:\n// CREATE (:Passenger {passenger_id: 'pass_pqr', first_name: 'Alice', ...})\n// Node Label: :Booking\n// Properties:\n//   booking_id: String (Constraint: UNIQUE)\n//   booking_datetime: DateTime\n//   status: String\n//   total_price: Float\n//   currency_code: String\n//   special_requests: String\n// Relationships:\n//   (:Passenger)-[:MADE_BOOKING]->(:Booking)\n//   (:Booking)-[:FOR_TRIP]->(:ScheduledTrip)\n// Example Cypher CREATE:\n// MATCH (p:Passenger {passenger_id: 'pass_pqr'}), (sched:ScheduledTrip {schedule_id: 'sched_1122'})\n// CREATE (p)-[:MADE_BOOKING]->(b:Booking {booking_id: 'book_zyx', ...})-[:FOR_TRIP]->(sched)\n// Node Label: :Ticket\n// Properties:\n//   ticket_id: String (Constraint: UNIQUE)\n//   seat_number: String\n//   ticket_type: String\n//   price: Float\n//   is_checked_in: Boolean\n//   qr_code_data: String\n// Relationships:\n//   (:Ticket)-[:PART_OF_BOOKING]->(:Booking)\n//   (:Ticket)-[:ASSIGNED_TO_CAR]->(:TrainCar)\n// Example Cypher CREATE:\n// MATCH (b:Booking {booking_id: 'book_zyx'}), (c:TrainCar {car_id: 'car_abc'})\n// CREATE (t:Ticket {ticket_id: 'tkt_1a2b', ...})-[:PART_OF_BOOKING]->(b), (t)-[:ASSIGNED_TO_CAR]->(c)\n// Node Label: :Staff\n// Properties:\n//   staff_id: String (Constraint: UNIQUE)\n//   first_name: String\n//   last_name: String\n//   role: String\n//   employee_number: String (Constraint: UNIQUE)\n//   hire_date: Date\n//   contact_email: String (Constraint: UNIQUE, if not null)\n//   contact_phone: String\n//   is_active: Boolean\n// Relationship (Optional):\n//   (:Staff)-[:BASED_AT]->(:Station)\n// Example Cypher CREATE:\n// CREATE (:Staff {staff_id: 'staff_mno', first_name: 'Bob', ...})\n// OPTIONAL MATCH (s:Station {station_id: 'station_xyz'}) // If primary_station_id exists\n// WITH s, staff_mno // Need to get the created staff node reference\n// WHERE s IS NOT NULL\n// CREATE (staff_mno)-[:BASED_AT]->(s)\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": "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": "Show me all patients who have scheduled appointments with doctors specializing in Pediatrics, along with their appointment times and the doctors' full names."}, {"role": "assistant", "content": "SELECT p.first_name, p.last_name, a.appointment_time, d.first_name AS doctor_first_name, d.last_name AS doctor_last_name FROM healthcare.patients p JOIN healthcare.appointments a ON p.patient_id = a.patient_id JOIN healthcare.doctors d ON a.doctor_id = d.doctor_id WHERE d.specialty = 'Pediatrics' ORDER BY a.appointment_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 healthcare.patients ( patient_id text PRIMARY KEY, first_name text, last_name text, date_of_birth date, gender text, address text, phone_number text, email text, emergency_contact_name text, emergency_contact_phone text, created_at timestamp, updated_at timestamp )\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 ( appointment_id text PRIMARY KEY, patient_id text, doctor_id text, appointment_time timestamp, duration_minutes int, reason text, status text, location_id text, notes text, created_at timestamp )\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 character varying(64) NOT NULL, record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, diagnosis_code character varying(20) NOT NULL, code_type character varying(10) NOT NULL DEFAULT 'ICD-10', description text, diagnosis_date date NOT NULL, status character varying(32) NOT NULL, is_chronic boolean DEFAULT false, PRIMARY KEY (diagnosis_id) )\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.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )\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 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": "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": "Find all nodes that were last seen in the last 30 days and have port numbers between 8000 and 9000."}, {"role": "assistant", "content": "SELECT node_id, ip_address, port FROM blockchain.nodes WHERE last_seen >= NOW() - INTERVAL '30 days' AND port BETWEEN 8000 AND 9000"}, {"role": "user", "content": "Can you also show the count of transactions sent from wallet addresses that share the same IP as these nodes?"}, {"role": "assistant", "content": "This query isn't possible with the current schema as there's no relationship between nodes IP addresses and wallet addresses."}, {"role": "user", "content": "Then just show me nodes that share the same IP address along with how many nodes share each IP."}, {"role": "assistant", "content": "SELECT ip_address, COUNT(*) as node_count FROM blockchain.nodes GROUP BY ip_address HAVING COUNT(*) > 1"}, {"role": "user", "content": "Now filter this to only show IP addresses with more than 3 nodes and include the earliest and latest last_seen timestamps."}, {"role": "assistant", "content": "SELECT ip_address, COUNT(*) as node_count, MIN(last_seen) as earliest_seen, MAX(last_seen) as latest_seen FROM blockchain.nodes GROUP BY ip_address HAVING COUNT(*) > 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.transactions ( transaction_id text, block_id text, sender_address text, receiver_address text, amount numeric, timestamp timestamp, signature text )\nCREATE TABLE blockchain.nodes ( node_id text, ip_address text, port integer, last_seen timestamp )\nCREATE TABLE blockchain.wallets ( wallet_id text, user_id text, address_id text, private_key text )\nCREATE TABLE blockchain.smart_contracts ( contract_id text, creator_address text, code text, timestamp timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show me all failed transactions where the gas_used is greater than 100,000, including the transaction_id and timestamp."}, {"role": "assistant", "content": "SELECT transaction_id, timestamp FROM web3.transactions WHERE status = 'failed' AND gas_used > 100000;"}, {"role": "user", "content": "Actually, I also need to see the from_address and the value of these transactions."}, {"role": "assistant", "content": "SELECT transaction_id, timestamp, from_address, value FROM web3.transactions WHERE status = 'failed' AND gas_used > 100000;"}, {"role": "user", "content": "There's a typo in your SQL, it should be '100000' not '100,000'. Also, sort the results by timestamp in descending order."}, {"role": "assistant", "content": "SELECT transaction_id, timestamp, from_address, value FROM web3.transactions WHERE status = 'failed' AND gas_used > 100000 ORDER BY timestamp DESC;"}, {"role": "user", "content": "Now filter to only show transactions from the last 30 days."}, {"role": "assistant", "content": "SELECT transaction_id, timestamp, from_address, value FROM web3.transactions WHERE status = 'failed' AND gas_used > 100000 AND timestamp >= NOW() - INTERVAL '30 days' ORDER BY timestamp 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 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)\n"}
{"conversations": [{"role": "user", "content": "Show each citizen's first and last notification IDs based on sent_at."}, {"role": "assistant", "content": "WITH bounds AS (\n  SELECT citizen_id,\n         MIN(sent_at) AS first_sent,\n         MAX(sent_at) AS last_sent\n  FROM government_services.notifications\n  GROUP BY citizen_id\n)\nSELECT n1.citizen_id,\n       n1.notification_id AS first_notification_id,\n       n2.notification_id AS last_notification_id\nFROM bounds b\nJOIN government_services.notifications n1\n  ON n1.citizen_id = b.citizen_id\n AND n1.sent_at = b.first_sent\nJOIN government_services.notifications n2\n  ON n2.citizen_id = b.citizen_id\n AND n2.sent_at = b.last_sent;"}], "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.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 the usernames and user IDs of all users whose bio contains the word 'developer'."}, {"role": "assistant", "content": "SELECT user_id, username\nFROM social_media.users\nWHERE bio ILIKE '%developer%';"}], "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 (\n    user_id character varying(64) NOT NULL,  -- unique identifier for the user\n    username character varying(50) NOT NULL UNIQUE, -- user's unique handle\n    email character varying(128) NOT NULL UNIQUE, -- user's email address\n    password_hash text NOT NULL, -- hashed password\n    full_name character varying(100), -- user's full name\n    profile_picture_url text, -- URL to the profile picture\n    bio text, -- short user biography\n    location character varying(100), -- user's location\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of account creation\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last profile update\n    is_verified boolean NOT NULL DEFAULT false, -- verification status\n    PRIMARY KEY (user_id)\n)\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 (\n    like_id character varying(64) NOT NULL, -- unique identifier for the like\n    user_id character varying(64) NOT NULL, -- identifier of the user who liked (FK to users.user_id)\n    post_id character varying(64), -- identifier of the post being liked (FK to posts.post_id, nullable)\n    comment_id character varying(64), -- identifier of the comment being liked (FK to comments.comment_id, nullable)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of when the like occurred\n    PRIMARY KEY (like_id),\n    CONSTRAINT unique_user_like UNIQUE (user_id, post_id, comment_id), -- prevent duplicate likes\n    CONSTRAINT check_like_target CHECK (post_id IS NOT NULL OR comment_id IS NOT NULL) -- ensure it likes something\n)\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 (\n    hashtag_id character varying(64) NOT NULL, -- unique identifier for the hashtag\n    tag_name character varying(100) NOT NULL UNIQUE, -- the actual hashtag text (without '#')\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when the hashtag was first used\n    PRIMARY KEY (hashtag_id)\n)\nCREATE TABLE social_media.conversations (\n    conversation_id character varying(64) NOT NULL, -- unique identifier for the conversation\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when conversation was initiated\n    last_message_at timestamp, -- timestamp of the last message in the conversation\n    is_group_chat boolean NOT NULL DEFAULT false, -- indicates if it's a group chat or direct message\n    group_name character varying(100), -- name of the group chat (if applicable)\n    PRIMARY KEY (conversation_id)\n)\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 (\n    setting_id character varying(64) NOT NULL, -- unique identifier for the setting entry\n    user_id character varying(64) NOT NULL UNIQUE, -- user the settings belong to (FK to users.user_id)\n    theme character varying(20) DEFAULT 'light', -- UI theme ('light', 'dark')\n    email_notifications_enabled boolean DEFAULT true, -- enable/disable email notifications\n    push_notifications_enabled boolean DEFAULT true, -- enable/disable push notifications\n    private_profile boolean DEFAULT false, -- is the user profile private\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last setting change\n    PRIMARY KEY (setting_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Get the five most recent public posts that have media_type = 'video', showing post_id, created_at, and the author's username."}, {"role": "assistant", "content": "SELECT\n  p.post_id,\n  p.created_at,\n  u.username\nFROM social_media.posts p\nJOIN social_media.users u\n  ON p.user_id = u.user_id\nWHERE p.visibility = 'public'\n  AND p.media_type = 'video'\nORDER BY p.created_at DESC\nLIMIT 5;"}, {"role": "user", "content": "Actually, filter to only include posts made by verified users."}, {"role": "assistant", "content": "SELECT\n  p.post_id,\n  p.created_at,\n  u.username\nFROM social_media.posts p\nJOIN social_media.users u\n  ON p.user_id = u.user_id\nWHERE p.visibility = 'public'\n  AND p.media_type = 'video'\n  AND u.is_verified = TRUE\nORDER BY p.created_at 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 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.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.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": "For each server, show its name and the total number of achievements available for the game it hosts."}, {"role": "assistant", "content": "SELECT s.server_name, s.region, COUNT(a.achievement_id) AS achievement_count\nFROM gaming_technology.servers s\nLEFT JOIN gaming_technology.achievements a ON s.game_id = a.game_id\nGROUP BY s.server_name, s.region;"}, {"role": "user", "content": "Exclude servers hosting games with no achievements."}, {"role": "assistant", "content": "SELECT s.server_name, s.region, COUNT(a.achievement_id) AS achievement_count\nFROM gaming_technology.servers s\nLEFT JOIN gaming_technology.achievements a ON s.game_id = a.game_id\nGROUP BY s.server_name, s.region\nHAVING COUNT(a.achievement_id) > 0;"}, {"role": "user", "content": "Also include each server's current_players and max_players."}, {"role": "assistant", "content": "SELECT s.server_name, s.region, s.current_players, s.max_players, COUNT(a.achievement_id) AS achievement_count\nFROM gaming_technology.servers s\nLEFT JOIN gaming_technology.achievements a ON s.game_id = a.game_id\nGROUP BY s.server_name, s.region, s.current_players, s.max_players\nHAVING COUNT(a.achievement_id) > 0;"}, {"role": "user", "content": "Sort by usage ratio (current_players divided by max_players) in descending order."}, {"role": "assistant", "content": "SELECT s.server_name, s.region, s.current_players, s.max_players, COUNT(a.achievement_id) AS achievement_count\nFROM gaming_technology.servers s\nLEFT JOIN gaming_technology.achievements a ON s.game_id = a.game_id\nGROUP BY s.server_name, s.region, s.current_players, s.max_players\nHAVING COUNT(a.achievement_id) > 0\nORDER BY (s.current_players::numeric / s.max_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.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.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 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) )\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": "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": "For each transaction, find its immediate next transaction by the same sender, listing the original transaction_id, the next transaction_id, and the time difference in minutes between them."}, {"role": "assistant", "content": "SELECT t1.transaction_id AS current_tx, t2.transaction_id AS next_tx, EXTRACT(EPOCH FROM (t2.timestamp - t1.timestamp)) / 60 AS diff_minutes FROM web3.transactions t1 JOIN web3.transactions t2 ON t2.from_address = t1.from_address AND t2.timestamp = (SELECT MIN(timestamp) FROM web3.transactions WHERE from_address = t1.from_address AND timestamp > t1.timestamp);"}], "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.transactions ( transaction_id text PRIMARY KEY, from_address text, to_address text, value numeric, gas_used int, gas_price numeric, block_number int, timestamp timestamp, input_data text, status text, nonce int )\n"}
{"conversations": [{"role": "user", "content": "Show me all trips that were delayed by more than 1 hour, including their vehicle and driver IDs, along with the origin and destination location IDs."}, {"role": "assistant", "content": "SELECT trip_id, vehicle_id, driver_id, origin_location_id, destination_location_id FROM transportation.trips WHERE EXTRACT(EPOCH FROM (actual_departure - scheduled_departure))/3600 > 1 AND status = 'Completed';"}, {"role": "user", "content": "Now include the passenger count for these trips, but only show trips that had more than 5 passengers."}, {"role": "assistant", "content": "SELECT trip_id, vehicle_id, driver_id, origin_location_id, destination_location_id, passenger_count FROM transportation.trips WHERE EXTRACT(EPOCH FROM (actual_departure - scheduled_departure))/3600 > 1 AND status = 'Completed' AND passenger_count > 5;"}, {"role": "user", "content": "Can you order these results by the delay time in descending order, showing the longest delays first?"}, {"role": "assistant", "content": "SELECT trip_id, vehicle_id, driver_id, origin_location_id, destination_location_id, passenger_count, (actual_departure - scheduled_departure) AS delay_time FROM transportation.trips WHERE EXTRACT(EPOCH FROM (actual_departure - scheduled_departure))/3600 > 1 AND status = 'Completed' AND passenger_count > 5 ORDER BY delay_time 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.trips (\n    trip_id character varying(64) NOT NULL,  -- unique identifier for a specific trip instance\n    route_id character varying(64), -- identifier of the route being followed (can be null for ad-hoc trips)\n    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle used\n    driver_id character varying(64) NOT NULL, -- identifier of the driver operating\n    scheduled_departure timestamp with time zone NOT NULL, -- planned departure time\n    actual_departure timestamp with time zone, -- actual departure time\n    scheduled_arrival timestamp with time zone NOT NULL, -- planned arrival time\n    actual_arrival timestamp with time zone, -- actual arrival time\n    origin_location_id character varying(64) NOT NULL, -- actual starting location (could differ from route origin)\n    destination_location_id character varying(64) NOT NULL, -- actual ending location (could differ from route destination)\n    status character varying(32) NOT NULL, -- e.g., Scheduled, In Progress, Completed, Delayed, Cancelled\n    passenger_count integer, -- number of passengers (if applicable)\n    cargo_manifest_id character varying(64), -- link to cargo details (if applicable)\n    PRIMARY KEY (trip_id)\n)\n"}
{"conversations": [{"role": "user", "content": "For each employee who has verified documents, show their full name and the total number of documents they have verified with a status of 'Verified'."}, {"role": "assistant", "content": "SELECT e.full_name, COUNT(d.document_id) FROM government_services.documents d JOIN employees e ON d.verified_by_employee_id = e.employee_id WHERE d.verification_status = 'Verified' GROUP BY e.full_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.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 )\n"}
{"conversations": [{"role": "user", "content": "I need to find all components associated with a specific supplier. Can you help with that?"}, {"role": "assistant", "content": "HGETALL component:<component_id>\nIF HGET component:<component_id> supplier_id = 'sup:ACME_AERO' THEN INCLUDE"}, {"role": "user", "content": "Can you also show me the material ID for each of these components?"}, {"role": "assistant", "content": "HGETALL component:<component_id>\nIF HGET component:<component_id> supplier_id = 'sup:ACME_AERO' THEN INCLUDE\nHGET component:<component_id> material_id"}, {"role": "user", "content": "What if I want to exclude components with a specific material ID?"}, {"role": "assistant", "content": "HGETALL component:<component_id>\nIF HGET component:<component_id> supplier_id = 'sup:ACME_AERO' THEN INCLUDE\nHGET component:<component_id> material_id\nIF HGET component:<component_id> material_id != 'mat:TI64' THEN INCLUDE"}, {"role": "user", "content": "Can you add the component name to the result as well?"}, {"role": "assistant", "content": "HGETALL component:<component_id>\nIF HGET component:<component_id> supplier_id = 'sup:ACME_AERO' THEN INCLUDE\nHGET component:<component_id> material_id\nIF HGET component:<component_id> material_id != 'mat:TI64' THEN INCLUDE\nHGET component:<component_id> component_name"}], "system": "You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement. \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": "What is the total investment_value per fundraising round for the year 2023? Order by total investment descending."}, {"role": "assistant", "content": "SELECT\n  substr(investment_date,1,7) AS month,\n  rounds_name,\n  SUM(investment_value) AS total_investment\nFROM project_fundraising_record\nWHERE investment_date LIKE '2023-%'\nGROUP BY substr(investment_date,1,7), rounds_name\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.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": "For each chain, which token had the highest number of smart money addresses buying it this week? Show the token symbol and narrative too."}, {"role": "assistant", "content": "SELECT chain, token_symbol, narrative, MAX(address_amount) AS max_buyers FROM smart_money_token_inflow WHERE type = 1 AND DATE_TRUNC('week', CURRENT_DATE) = DATE_TRUNC('week', CURRENT_DATE) GROUP BY chain, token_symbol, narrative;"}, {"role": "user", "content": "I got an error, I think the filter for the week may be wrong. Please revise the query so that it only counts buys from the current week."}, {"role": "assistant", "content": "SELECT chain, token_symbol, narrative, address_amount AS buyers FROM smart_money_token_inflow WHERE type = 1 AND EXTRACT(week FROM CURRENT_DATE) = EXTRACT(week FROM CURRENT_DATE) AND EXTRACT(year FROM CURRENT_DATE) = EXTRACT(year FROM CURRENT_DATE) ORDER BY chain, buyers 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 smart_money_token_inflow ( token_address character varying(100) NOT NULL, -- the token's address token_symbol character varying(100), -- the tokens's symbol token_amount numeric(38,2), -- the absolute value of the amount if user bought minus  the amount user sold of this token usd_value numeric(38,2), -- the absolute usd value of the bought token minus sold token avg_price numeric(38,6), -- the average cost price of user spent on this token type int, -- the direction of the trade on this token. 1 means buying, 2 means selling address_amount integer, -- the amount of the user bought this token narrative character varying(100), -- the category or narrative of the token chain character varying(100), -- the chain that the token resides ,PRIMARY KEY (token_address, chain) )\n"}
{"conversations": [{"role": "user", "content": "Show me the usernames and the group names of group chats where each user has posted at least one post containing a hashtag."}, {"role": "assistant", "content": "SELECT u.username, c.group_name\nFROM social_media.users u\nJOIN social_media.posts p ON u.user_id = p.user_id\nJOIN social_media.post_hashtags ph ON p.post_id = ph.post_id\nJOIN social_media.conversations c ON p.user_id = u.user_id AND c.is_group_chat = TRUE\nGROUP BY u.username, c.group_name;"}, {"role": "user", "content": "Can you also show when each group chat was created?"}, {"role": "assistant", "content": "SELECT u.username, c.group_name, c.created_at\nFROM social_media.users u\nJOIN social_media.posts p ON u.user_id = p.user_id\nJOIN social_media.post_hashtags ph ON p.post_id = ph.post_id\nJOIN social_media.conversations c ON p.user_id = u.user_id AND c.is_group_chat = TRUE\nGROUP BY u.username, c.group_name, c.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.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.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 )\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": "Show me all home loans (loan_id, principal_amount, interest_rate) where the current principal balance is more than 75% of the original principal amount, along with the account_id and employee details (first_name, last_name) of the employee who processed the loan application."}, {"role": "assistant", "content": "SELECT l.loan_id, l.principal_amount, l.interest_rate, l.account_id, e.first_name, e.last_name FROM financial_services.loans l JOIN financial_services.employees e ON l.account_id = e.employee_id WHERE l.loan_type = 'Home' AND l.current_principal_balance > (l.principal_amount * 0.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 financial_services.transactions ( transaction_id.text, account_id.text, related_account_id.text, transaction_type.text, amount.numeric, currency.text, transaction_date.timestamp, effective_date.date, description.text, status.text, reference_number.text )\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.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 ( employee_id.text, first_name.text, last_name.text, job_title.text, department.text, branch_id.text, email.text, phone_extension.text, hire_date.date, termination_date.date, manager_id.text, status.text )\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": "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": "Find all customers who have made a premium payment and list their first name, last name, email, and the total amount they have paid across all their payments."}, {"role": "assistant", "content": "SELECT T1.first_name, T1.last_name, T1.email, SUM(T2.amount_paid) FROM insurance.customers AS T1 JOIN insurance.premium_payments AS T2 ON T1.customer_id = T2.customer_id GROUP BY T1.customer_id, T1.first_name, T1.last_name, T1.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 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.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": "Get the total payment amount grouped by currency."}, {"role": "assistant", "content": "SELECT currency_code, SUM(amount) AS total_amount\nFROM hospitality_technology.payments\nGROUP BY currency_code;"}, {"role": "user", "content": "Now show only those currencies where the total amount exceeds 10000."}, {"role": "assistant", "content": "SELECT currency_code, SUM(amount) AS total_amount\nFROM hospitality_technology.payments\nGROUP BY currency_code\nHAVING SUM(amount) > 10000;"}], "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)\nCREATE TABLE hospitality_technology.payments (\n    payment_id character varying(64) NOT NULL,  -- unique identifier for the payment transaction\n    reservation_id character varying(64), -- FK to reservations (if payment is for a stay)\n    guest_id character varying(64) NOT NULL, -- FK to guests (who paid)\n    bill_id character varying(64), -- FK to bills/invoices this payment applies to\n    amount numeric(12,2) NOT NULL, -- amount of the payment\n    currency_code character varying(3) NOT NULL, -- ISO currency code (e.g., USD, EUR)\n    payment_method character varying(50) NOT NULL, -- e.g., CreditCard, Cash, BankTransfer, Points, Voucher\n    card_type character varying(50), -- e.g., Visa, MasterCard, Amex (if CC)\n    card_last_four character varying(4), -- last 4 digits of CC (if CC)\n    transaction_ref character varying(128), -- reference ID from payment gateway or processor\n    payment_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, -- when the payment occurred\n    status character varying(50) NOT NULL, -- e.g., Pending, Succeeded, Failed, Refunded, Disputed\n    staff_id_processed character varying(64), -- FK to staff (who processed the payment)\n    notes text, -- notes about the payment\n    PRIMARY KEY (payment_id),\n    FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id),\n    FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id),\n    FOREIGN KEY (staff_id_processed) REFERENCES hospitality_technology.staff(staff_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all transaction IDs, sender addresses, and amounts for transactions received by '0xFEDCBA9876543210FEDCBA9876543210FEDCBA98' between '2023-01-01' and '2023-03-31'."}, {"role": "assistant", "content": "SELECT transaction_id, sender_address, amount FROM blockchain.transactions WHERE receiver_address = '0xFEDCBA9876543210FEDCBA9876543210FEDCBA98' AND timestamp BETWEEN '2023-01-01' AND '2023-03-31';"}], "system": "You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement. \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": "List the full names of citizens who have made payments for services that are currently inactive. Also show the service name and payment amount."}, {"role": "assistant", "content": "SELECT c.first_name || ' ' || c.last_name AS full_name, s.service_name, p.amount\nFROM government_services.payments p\nJOIN government_services.citizens c ON p.citizen_id = c.citizen_id\nJOIN government_services.services s ON p.service_id = s.service_id\nWHERE s.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.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, 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, 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 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 (\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": "For each patient, find the next appointment after each one. Return patient_id, appointment_id, next_appointment_id, and the waiting time in minutes between them."}, {"role": "assistant", "content": "SELECT A.patient_id,\n       A.appointment_id AS current_id,\n       B.appointment_id AS next_id,\n       EXTRACT(EPOCH FROM (B.appointment_time - A.appointment_time)) / 60 AS wait_minutes\nFROM healthcare.appointments A\nJOIN healthcare.appointments B\n  ON A.patient_id = B.patient_id\n AND B.appointment_time = (\n       SELECT MIN(appointment_time)\n       FROM healthcare.appointments\n       WHERE patient_id = A.patient_id\n         AND appointment_time > A.appointment_time\n   );"}, {"role": "user", "content": "Now include only the pairs where the waiting time is less than 30 minutes."}, {"role": "assistant", "content": "SELECT A.patient_id,\n       A.appointment_id AS current_id,\n       B.appointment_id AS next_id,\n       EXTRACT(EPOCH FROM (B.appointment_time - A.appointment_time)) / 60 AS wait_minutes\nFROM healthcare.appointments A\nJOIN healthcare.appointments B\n  ON A.patient_id = B.patient_id\n AND B.appointment_time = (\n       SELECT MIN(appointment_time)\n       FROM healthcare.appointments\n       WHERE patient_id = A.patient_id\n         AND appointment_time > A.appointment_time\n   )\nWHERE EXTRACT(EPOCH FROM (B.appointment_time - A.appointment_time)) / 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 healthcare.appointments ( appointment_id text PRIMARY KEY, patient_id text, doctor_id text, appointment_time timestamp, duration_minutes int, reason text, status text, location_id text, notes text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List the first name and last name of citizens who have scheduled appointments, along with the scheduled start time and purpose of their appointments."}, {"role": "assistant", "content": "SELECT T1.first_name, T1.last_name, T2.scheduled_start_time, T2.purpose FROM government_services.citizens AS T1 JOIN government_services.appointments 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.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.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.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": "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": "Can you show me all developers along with the year they were founded and their website, grouped by country?"}, {"role": "assistant", "content": "SELECT country, array_agg(name) AS developers, array_agg(founded_year) AS founded_years, array_agg(website) AS websites FROM gaming_technology.developers GROUP BY country;"}, {"role": "user", "content": "Can you add the number of developers per country to the result?"}, {"role": "assistant", "content": "SELECT country, COUNT(*) AS developer_count, array_agg(name) AS developers, array_agg(founded_year) AS founded_years, array_agg(website) AS websites FROM gaming_technology.developers GROUP BY country;"}, {"role": "user", "content": "I'd like to see only countries with at least two developers. Can you modify the query?"}, {"role": "assistant", "content": "SELECT country, COUNT(*) AS developer_count, array_agg(name) AS developers, array_agg(founded_year) AS founded_years, array_agg(website) AS websites FROM gaming_technology.developers GROUP BY country HAVING COUNT(*) >= 2;"}, {"role": "user", "content": "Actually, could you also include the earliest founded year of a developer in each country?"}, {"role": "assistant", "content": "SELECT country, COUNT(*) AS developer_count, MIN(founded_year) AS earliest_founded_year, array_agg(name) AS developers, array_agg(founded_year) AS founded_years, array_agg(website) AS websites FROM gaming_technology.developers GROUP BY country 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 gaming_technology.developers ( developer_id.uuid, name.text, country.text, founded_year.integer, website.text, created_at.timestamptz )\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": "What is the schedule of trains arriving at platform 1A at station XYZ on December 25th, 2023?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information about train schedules or specific arrival times as this data is not included in the platform management table. For train schedules, please refer to the train timetable or contact the station's customer service."}], "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 (\n    platform_id character varying(64) NOT NULL, -- Unique identifier for the platform\n    station_id character varying(64) NOT NULL, -- Foreign key referencing stations\n    platform_number character varying(10) NOT NULL, -- Platform identifier (e.g., '1A', '5')\n    track_number character varying(10), -- Associated track number, if different\n    status character varying(32) NOT NULL DEFAULT 'Operational', -- e.g., Operational, Maintenance, Closed\n    length_meters numeric(8,2), -- Length of the platform in meters\n    accessible boolean NOT NULL DEFAULT false, -- Is the platform accessible (e.g., wheelchair)?\n    PRIMARY KEY (platform_id),\n    FOREIGN KEY (station_id) REFERENCES train_station_management.stations(station_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all guests who have never left a review, including their full name and email."}, {"role": "assistant", "content": "SELECT g.guest_id, g.first_name, g.last_name, g.email \nFROM hospitality_technology.guests g \nLEFT JOIN hospitality_technology.reviews r ON g.guest_id = r.guest_id \nWHERE r.review_id IS NULL;"}, {"role": "user", "content": "Can you also include their phone number?"}, {"role": "assistant", "content": "SELECT g.guest_id, g.first_name, g.last_name, g.email, g.phone_number \nFROM hospitality_technology.guests g \nLEFT JOIN hospitality_technology.reviews r ON g.guest_id = r.guest_id \nWHERE r.review_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 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.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.services ( service_id text PRIMARY KEY, property_id text, service_name text, description text, category text, price numeric, unit text, is_available boolean, department text )\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.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": "Show the number of employees in each department."}, {"role": "assistant", "content": "SELECT department, COUNT(*) AS employee_count\nFROM financial_services.employees\ngroup BY department;"}, {"role": "user", "content": "Exclude departments that have less than 3 employees."}, {"role": "assistant", "content": "SELECT department, COUNT(*) AS employee_count\nFROM financial_services.employees\ngroup BY department\nHAVING COUNT(*) >= 3;"}, {"role": "user", "content": "Can you also show the average hire_date for employees in each department?"}, {"role": "assistant", "content": "SELECT department, COUNT(*) AS employee_count, AVG(hire_date) AS average_hire_date\nFROM financial_services.employees\ngroup BY department\nHAVING COUNT(*) >= 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 financial_services.accounts ( account_id text PRIMARY KEY, customer_id text, account_number text, account_type text, balance numeric, currency text, opened_date date, status text, interest_rate numeric, last_updated_at timestamp )\nCREATE TABLE financial_services.transactions ( transaction_id text PRIMARY KEY, account_id text, related_account_id text, transaction_type text, amount numeric, currency text, transaction_date timestamp, effective_date date, description text, status text, reference_number text )\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 bigserial PRIMARY KEY, security_id text, data_timestamp timestamp, open_price numeric, high_price numeric, low_price numeric, close_price numeric, adjusted_close_price numeric, volume bigint, source text )\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": "List all passengers who have never made a booking, showing their passenger_id, first_name, last_name, and email."}, {"role": "assistant", "content": "SELECT\n    p.passenger_id,\n    p.first_name,\n    p.last_name,\n    p.email\nFROM transportation.passengers p\nLEFT JOIN transportation.bookings b ON p.passenger_id = b.passenger_id\nWHERE b.booking_id IS NULL;"}, {"role": "user", "content": "Actually, please include their phone_number as well."}, {"role": "assistant", "content": "SELECT\n    p.passenger_id,\n    p.first_name,\n    p.last_name,\n    p.email,\n    p.phone_number\nFROM transportation.passengers p\nLEFT JOIN transportation.bookings b ON p.passenger_id = b.passenger_id\nWHERE b.booking_id IS NULL;"}, {"role": "user", "content": "Also, limit to passengers created after '2022-01-01'."}, {"role": "assistant", "content": "SELECT\n    p.passenger_id,\n    p.first_name,\n    p.last_name,\n    p.email,\n    p.phone_number\nFROM transportation.passengers p\nLEFT JOIN transportation.bookings b ON p.passenger_id = b.passenger_id\nWHERE b.booking_id IS NULL\n  AND p.created_at > '2022-01-01';"}, {"role": "user", "content": "Finally, sort the results by last_name in ascending order."}, {"role": "assistant", "content": "SELECT\n    p.passenger_id,\n    p.first_name,\n    p.last_name,\n    p.email,\n    p.phone_number\nFROM transportation.passengers p\nLEFT JOIN transportation.bookings b ON p.passenger_id = b.passenger_id\nWHERE b.booking_id IS NULL\n  AND p.created_at > '2022-01-01'\nORDER BY p.last_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 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 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, 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.passengers (\n    passenger_id character varying(64) NOT NULL,  -- unique identifier for the passenger\n    first_name character varying(128) NOT NULL, -- passenger's first name\n    last_name character varying(128) NOT NULL, -- passenger's last name\n    email character varying(128) UNIQUE, -- email address\n    phone_number character varying(32) UNIQUE, -- phone number\n    date_of_birth date, -- passenger's date of birth\n    loyalty_program_id character varying(64), -- identifier for loyalty program membership\n    created_at timestamp with time zone NOT NULL, -- time when the passenger record was created\n    PRIMARY KEY (passenger_id)\n)\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": "Find all pairs of transactions that occurred in the same block and were sent to the same address. Show both transaction IDs, the shared recipient address, and the block number."}, {"role": "assistant", "content": "SELECT t1.transaction_id AS tx1,\n       t2.transaction_id AS tx2,\n       t1.to_address,\n       t1.block_number\nFROM transactions t1\nJOIN transactions t2\n  ON t1.to_address = t2.to_address\n AND t1.block_number = t2.block_number\n AND t1.transaction_id < t2.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.transactions ( transaction_id text, from_address text, to_address text, value numeric, gas_used integer, gas_price numeric, block_number integer, timestamp timestamp, input_data text, status text, nonce integer )\n"}
{"conversations": [{"role": "user", "content": "List every diagnosis description paired with every insurance plan's website."}, {"role": "assistant", "content": "SELECT T1.description, T2.website FROM healthcare.diagnoses AS T1 CROSS JOIN healthcare.insurance_plans AS T2;"}, {"role": "user", "content": "Only include chronic diagnoses and plans whose website ends with '.org'."}, {"role": "assistant", "content": "SELECT T1.description, T2.website FROM healthcare.diagnoses AS T1 CROSS JOIN healthcare.insurance_plans AS T2 WHERE T1.is_chronic = true AND T2.website LIKE '%.org';"}], "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 character varying(64) NOT NULL, record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, diagnosis_code character varying(20) NOT NULL, code_type character varying(10) NOT NULL DEFAULT 'ICD-10', description text, diagnosis_date date NOT NULL, status character varying(32) NOT NULL, is_chronic boolean DEFAULT false, PRIMARY KEY (diagnosis_id) )\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": "Find all medical records where the vitals JSON field contains a blood pressure reading with systolic higher than 140, and show the patient_id, record_date, and vitals."}, {"role": "assistant", "content": "SELECT patient_id, record_date, vitals FROM healthcare.medical_records WHERE (vitals->>'blood_pressure_systolic')::integer > 140;"}], "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.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": "List all cryptocurrency assets that have been traded at least 50 times, 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 HAVING COUNT(t.trade_id) >= 50 ORDER BY trade_count DESC;"}, {"role": "user", "content": "Now filter these results to only show assets where the average trade price is above $100."}, {"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 HAVING COUNT(t.trade_id) >= 50 AND AVG(t.price) > 100 ORDER BY avg_price DESC;"}, {"role": "user", "content": "Can you also include the most recent trade timestamp for each asset?"}, {"role": "assistant", "content": "SELECT a.asset_id, a.name, a.symbol, COUNT(t.trade_id) AS trade_count, AVG(t.price) AS avg_price, MAX(t.traded_at) AS last_trade 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 HAVING COUNT(t.trade_id) >= 50 AND AVG(t.price) > 100 ORDER BY avg_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 (\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)\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 (\n    order_id character varying(64) NOT NULL,  -- unique identifier for the order\n    user_id character varying(64) NOT NULL, -- identifier of the user placing the order\n    wallet_id character varying(64) NOT NULL, -- identifier of the wallet used for the order\n    asset_id character varying(64) NOT NULL, -- identifier of the asset being traded\n    order_type character varying(32) NOT NULL, -- type of the order (e.g., buy, sell)\n    quantity numeric(38,14) NOT NULL, -- quantity of the asset in the order\n    price numeric(38,14) NOT NULL, -- price per unit of the asset\n    status character varying(32) NOT NULL, -- status of the order (e.g., open, filled, canceled)\n    created_at timestamp NOT NULL, -- time when the order was created\n    PRIMARY KEY (order_id)\n)\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 (\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.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.peers (\n    peer_id character varying(64) NOT NULL,  -- unique identifier for the peer\n    ip_address character varying(15) NOT NULL, -- IP address of the peer\n    port integer NOT NULL, -- port number of the peer\n    last_seen timestamp NOT NULL, -- last time the peer was active\n    PRIMARY KEY (peer_id)\n)\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)\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)\n"}
{"conversations": [{"role": "user", "content": "I want to know, for each conversation participant, how many unread messages they have. Return participant_id, conversation_id, and unread_count."}, {"role": "assistant", "content": "SELECT cp.participant_id,\n       cp.conversation_id,\n       COUNT(m.message_id) AS unread_count\nFROM social_media.conversation_participants cp\nJOIN social_media.messages m\n  ON m.conversation_id = cp.conversation_id\nWHERE m.sent_at > COALESCE(cp.last_read_at, '1970-01-01'::timestamp)\nGROUP BY cp.participant_id, cp.conversation_id;"}, {"role": "user", "content": "Can you filter the results to only include participants who joined the conversation before the earliest unread message was sent?"}, {"role": "assistant", "content": "SELECT cp.participant_id,\n       cp.conversation_id,\n       COUNT(m.message_id) AS unread_count\nFROM social_media.conversation_participants cp\nJOIN social_media.messages m\n  ON m.conversation_id = cp.conversation_id\nWHERE m.sent_at > COALESCE(cp.last_read_at, '1970-01-01'::timestamp)\nGROUP BY cp.participant_id, cp.conversation_id\nHAVING cp.joined_at < MIN(m.sent_at);"}, {"role": "user", "content": "Also, include the timestamp of the most recent unread message for each participant as last_unread_at."}, {"role": "assistant", "content": "SELECT cp.participant_id,\n       cp.conversation_id,\n       COUNT(m.message_id)   AS unread_count,\n       MAX(m.sent_at)        AS last_unread_at\nFROM social_media.conversation_participants cp\nJOIN social_media.messages m\n  ON m.conversation_id = cp.conversation_id\nWHERE m.sent_at > COALESCE(cp.last_read_at, '1970-01-01'::timestamp)\nGROUP BY cp.participant_id, cp.conversation_id\nHAVING cp.joined_at < MIN(m.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 social_media.posts (\n    post_id character varying(64) NOT NULL, -- unique identifier for the post\n    user_id character varying(64) NOT NULL, -- identifier of the user who created the post (FK to users.user_id)\n    content text, -- textual content of the post\n    media_url text, -- URL to attached media (image/video)\n    media_type character varying(20), -- type of media ('image', 'video', null)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of post creation\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last post edit\n    visibility character varying(20) NOT NULL DEFAULT 'public', -- visibility ('public', 'friends', 'private')\n    location_lat numeric(9,6), -- latitude of post location\n    location_lon numeric(9,6), -- longitude of post location\n    PRIMARY KEY (post_id)\n)\nCREATE TABLE social_media.likes (\n    like_id character varying(64) NOT NULL, -- unique identifier for the like\n    user_id character varying(64) NOT NULL, -- identifier of the user who liked (FK to users.user_id)\n    post_id character varying(64), -- identifier of the post being liked (FK to posts.post_id, nullable)\n    comment_id character varying(64), -- identifier of the comment being liked (FK to comments.comment_id, nullable)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of when the like occurred\n    PRIMARY KEY (like_id),\n    CONSTRAINT unique_user_like UNIQUE (user_id, post_id, comment_id), -- prevent duplicate likes\n    CONSTRAINT check_like_target CHECK (post_id IS NOT NULL OR comment_id IS NOT NULL) -- ensure it likes something\n)\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.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 (\n    setting_id character varying(64) NOT NULL, -- unique identifier for the setting entry\n    user_id character varying(64) NOT NULL UNIQUE, -- user the settings belong to (FK to users.user_id)\n    theme character varying(20) DEFAULT 'light', -- UI theme ('light', 'dark')\n    email_notifications_enabled boolean DEFAULT true, -- enable/disable email notifications\n    push_notifications_enabled boolean DEFAULT true, -- enable/disable push notifications\n    private_profile boolean DEFAULT false, -- is the user profile private\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last setting change\n    PRIMARY KEY (setting_id)\n)\n"}
{"conversations": [{"role": "user", "content": "For each vehicle, show the vehicle_id, license_plate, date of its most recent trip (actual_arrival), and the odometer_reading at its latest maintenance service."}, {"role": "assistant", "content": "SELECT\n    v.vehicle_id,\n    v.license_plate,\n    (\n        SELECT MAX(t.actual_arrival)\n        FROM transportation.trips t\n        WHERE t.vehicle_id = v.vehicle_id\n    ) AS last_trip_arrival,\n    ml.odometer_reading\nFROM transportation.vehicles v\nLEFT JOIN LATERAL (\n    SELECT odometer_reading\n    FROM transportation.maintenance_logs ml\n    WHERE ml.vehicle_id = v.vehicle_id\n    ORDER BY ml.service_date DESC\n    LIMIT 1\n) ml 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 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 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, 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.passengers (\n    passenger_id character varying(64) NOT NULL,  -- unique identifier for the passenger\n    first_name character varying(128) NOT NULL, -- passenger's first name\n    last_name character varying(128) NOT NULL, -- passenger's last name\n    email character varying(128) UNIQUE, -- email address\n    phone_number character varying(32) UNIQUE, -- phone number\n    date_of_birth date, -- passenger's date of birth\n    loyalty_program_id character varying(64), -- identifier for loyalty program membership\n    created_at timestamp with time zone NOT NULL, -- time when the passenger record was created\n    PRIMARY KEY (passenger_id)\n)\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": "Show me the top 5 ERC20 tokens with the highest total supply, along with their names and contract addresses, but only include tokens where the price is greater than $0.10."}, {"role": "assistant", "content": "SELECT tm.name, tm.contract_address, tm.total_supply FROM token_metas tm JOIN token_prices_latest tpl ON tm.contract_address = tpl.address WHERE tm.is_erc20 = 1 AND tpl.price > 0.10 ORDER BY CAST(tm.total_supply AS decimal) DESC LIMIT 5;"}, {"role": "user", "content": "Can you also include the symbol and decimals for these tokens?"}, {"role": "assistant", "content": "SELECT tm.name, tm.symbol, tm.contract_address, tm.total_supply, tm.decimals FROM token_metas tm JOIN token_prices_latest tpl ON tm.contract_address = tpl.address WHERE tm.is_erc20 = 1 AND tpl.price > 0.10 ORDER BY CAST(tm.total_supply AS decimal) DESC LIMIT 5;"}, {"role": "user", "content": "Now filter these results to only show tokens with decimals equal to 18."}, {"role": "assistant", "content": "SELECT tm.name, tm.symbol, tm.contract_address, tm.total_supply, tm.decimals FROM token_metas tm JOIN token_prices_latest tpl ON tm.contract_address = tpl.address WHERE tm.is_erc20 = 1 AND tpl.price > 0.10 AND tm.decimals = 18 ORDER BY CAST(tm.total_supply AS decimal) 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(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 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 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 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 varchar NOT NULL, status varchar NOT NULL, collection_type varchar NOT NULL, package_id varchar NOT NULL, previous_transaction varchar NOT NULL, display varchar NOT NULL, owner varchar NOT NULL, name varchar 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_balances ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar 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 ( 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 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_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": "Show me the top 5 NFT collections on Ethereum with the highest number of unique owners, along with their names and floor prices."}, {"role": "assistant", "content": "SELECT nc.name, nc.floor_price, COUNT(DISTINCT nh.wallet_address) AS unique_owners FROM nft_collections nc JOIN nft_holders nh ON nc.contract_address = nh.contract_address WHERE nc.blockchain = 'Ethereum' GROUP BY nc.name, nc.floor_price ORDER BY unique_owners DESC LIMIT 5;"}, {"role": "user", "content": "Can you modify the query to also include the banner image URL and filter to only show collections with a floor price greater than 0.5 ETH?"}, {"role": "assistant", "content": "SELECT nc.name, nc.floor_price, nc.banner_image_url, COUNT(DISTINCT nh.wallet_address) AS unique_owners FROM nft_collections nc JOIN nft_holders nh ON nc.contract_address = nh.contract_address WHERE nc.blockchain = 'Ethereum' AND CAST(nc.floor_price AS decimal) > 0.5 GROUP BY nc.name, nc.floor_price, nc.banner_image_url ORDER BY unique_owners DESC LIMIT 5;"}, {"role": "user", "content": "Now join this with the nft_metadata table to include the average rarity score for these collections."}, {"role": "assistant", "content": "SELECT nc.name, nc.floor_price, nc.banner_image_url, AVG(nm.rarity_score) AS avg_rarity_score, COUNT(DISTINCT nh.wallet_address) AS unique_owners FROM nft_collections nc JOIN nft_holders nh ON nc.contract_address = nh.contract_address JOIN nft_metadata nm ON nc.contract_address = nm.contract_address WHERE nc.blockchain = 'Ethereum' AND CAST(nc.floor_price AS decimal) > 0.5 GROUP BY nc.name, nc.floor_price, nc.banner_image_url ORDER BY unique_owners 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 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 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_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": "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": "For each pair of origin and destination location IDs, show the number of completed trips between them."}, {"role": "assistant", "content": "SELECT origin_location_id, destination_location_id, COUNT(*) AS completed_trip_count FROM transportation.trips WHERE status = 'Completed' GROUP BY origin_location_id, destination_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.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 )\n"}
{"conversations": [{"role": "user", "content": "List all users who have set their location to 'Berlin'."}, {"role": "assistant", "content": "SELECT user_id, username, email, full_name, location\nFROM social_media.users\nWHERE location = 'Berlin';"}], "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 character varying(64) NOT NULL, username character varying(50) NOT NULL UNIQUE, email character varying(128) NOT NULL UNIQUE, password_hash text NOT NULL, full_name character varying(100), profile_picture_url text, bio text, location character varying(100), created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, is_verified boolean NOT NULL DEFAULT false, PRIMARY KEY (user_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.hashtags ( hashtag_id text, tag_name text, created_at timestamp )\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 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": "Find all wallet addresses that don't have an associated user_id."}, {"role": "assistant", "content": "SELECT address_id, private_key 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 LEFT JOIN blockchain.transactions t ON w.address_id = t.sender_address WHERE w.user_id IS NULL;"}, {"role": "user", "content": "This query seems incorrect because the transactions table isn't in the schema. Can you modify it to just show the wallet information?"}, {"role": "assistant", "content": "SELECT address_id, private_key FROM blockchain.wallets WHERE 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 wallet_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": "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": "For each doctor, calculate the total duration of all their appointments. Show doctor_id and the sum of duration_minutes."}, {"role": "assistant", "content": "SELECT doctor_id, SUM(duration_minutes) AS total_duration FROM healthcare.appointments GROUP BY doctor_id;"}, {"role": "user", "content": "Filter this list to only show doctors whose total appointment duration is more than 500 minutes, and order the results by total duration ascending."}, {"role": "assistant", "content": "SELECT doctor_id, SUM(duration_minutes) AS total_duration FROM healthcare.appointments GROUP BY doctor_id HAVING SUM(duration_minutes) > 500 ORDER BY total_duration 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 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 )\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": "What is the maintenance schedule for platform 3 at station DEF for the next month?"}, {"role": "assistant", "content": "I'm sorry, but I don't have access to the maintenance schedule for platforms. The data I have only includes static information about platform details such as ID, station, number, track, status, length, and accessibility. For maintenance schedules, you may need to consult the station management or relevant department."}], "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": "Generate a report showing the total number of achievement unlocks broken down by the calendar day they occurred. Show the date and the total number of unlocks for that day."}, {"role": "assistant", "content": "SELECT DATE(unlocked_at) AS unlock_date, COUNT(player_achievement_id) AS unlock_count FROM gaming_technology.player_achievements GROUP BY DATE(unlocked_at);"}, {"role": "user", "content": "Only show days with more than 50 unlocks."}, {"role": "assistant", "content": "SELECT DATE(unlocked_at) AS unlock_date, COUNT(player_achievement_id) AS unlock_count FROM gaming_technology.player_achievements GROUP BY DATE(unlocked_at) HAVING COUNT(player_achievement_id) > 50;"}, {"role": "user", "content": "Also include the number of unique players who unlocked achievements on those days."}, {"role": "assistant", "content": "SELECT DATE(unlocked_at) AS unlock_date, COUNT(player_achievement_id) AS unlock_count, COUNT(DISTINCT player_id) AS unique_player_count FROM gaming_technology.player_achievements GROUP BY DATE(unlocked_at) HAVING COUNT(player_achievement_id) > 50;"}, {"role": "user", "content": "Order the results by unlock_count descending and limit to the top 10 days."}, {"role": "assistant", "content": "SELECT DATE(unlocked_at) AS unlock_date, COUNT(player_achievement_id) AS unlock_count, COUNT(DISTINCT player_id) AS unique_player_count FROM gaming_technology.player_achievements GROUP BY DATE(unlocked_at) HAVING COUNT(player_achievement_id) > 50 ORDER BY unlock_count 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 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) )\n"}
{"conversations": [{"role": "user", "content": "Retrieve the names of all properties that have listed room types, along with the name of each room type available at that property."}, {"role": "assistant", "content": "SELECT t1.property_name, t2.type_name FROM hospitality_technology.properties AS t1 INNER JOIN hospitality_technology.room_types AS t2 ON t1.property_id = t2.property_id;"}, {"role": "user", "content": "Now, filter this list to only include room types with a base rate above 300."}, {"role": "assistant", "content": "SELECT t1.property_name, t2.type_name FROM hospitality_technology.properties AS t1 INNER JOIN hospitality_technology.room_types AS t2 ON t1.property_id = t2.property_id WHERE t2.base_rate > 300;"}], "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) )\nCREATE TABLE hospitality_technology.payments ( payment_id character varying(64) NOT NULL, reservation_id character varying(64), guest_id character varying(64) NOT NULL, bill_id character varying(64), amount numeric(12,2) NOT NULL, currency_code character varying(3) NOT NULL, payment_method character varying(50) NOT NULL, card_type character varying(50), card_last_four character varying(4), transaction_ref character varying(128), payment_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, status character varying(50) NOT NULL, staff_id_processed character varying(64), notes text, PRIMARY KEY (payment_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (staff_id_processed) REFERENCES hospitality_technology.staff(staff_id) )\nCREATE TABLE hospitality_technology.reviews (\n    review_id character varying(64) NOT NULL,  -- unique identifier for the review\n    property_id character varying(64) NOT NULL, -- FK to properties table\n    reservation_id character varying(64) UNIQUE, -- FK to reservations (link review to a specific stay, optional but good)\n    guest_id character varying(64) NOT NULL, -- FK to guests table\n    rating_overall integer, -- overall score (e.g., 1-5 or 1-10)\n    rating_cleanliness integer,\n    rating_service integer,\n    rating_location integer,\n    rating_value integer,\n    comment text, -- guest's written feedback\n    review_source character varying(100), -- e.g., DirectSurvey, TripAdvisor, Google, Booking.com\n    review_date timestamp with time zone NOT NULL DEFAULT current_timestamp, -- when the review was submitted\n    is_public boolean DEFAULT true, -- whether the review is publicly visible\n    staff_response text, -- official response from the property\n    response_staff_id character varying(64), -- FK to staff (who responded)\n    response_date timestamp with time zone, -- when the response was posted\n    PRIMARY KEY (review_id),\n    FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id),\n    FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id),\n    FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id),\n    FOREIGN KEY (response_staff_id) REFERENCES hospitality_technology.staff(staff_id)\n)\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 unique actions that have been logged in the system."}, {"role": "assistant", "content": "SELECT DISTINCT action FROM trading_platform.logs;"}], "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": "Show me the total number of reservations and the sum of total_amount for each booking_source."}, {"role": "assistant", "content": "SELECT r.booking_source,\n       COUNT(*) AS reservation_count,\n       SUM(r.total_amount) AS total_revenue\nFROM hospitality_technology.reservations r\nGROUP BY r.booking_source;"}, {"role": "user", "content": "Now only include booking sources where the total_revenue exceeds 5000."}, {"role": "assistant", "content": "SELECT r.booking_source,\n       COUNT(*) AS reservation_count,\n       SUM(r.total_amount) AS total_revenue\nFROM hospitality_technology.reservations r\nGROUP BY r.booking_source\nHAVING SUM(r.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 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.payments ( payment_id character varying(64) NOT NULL, reservation_id character varying(64), guest_id character varying(64) NOT NULL, bill_id character varying(64), amount numeric(12,2) NOT NULL, currency_code character varying(3) NOT NULL, payment_method character varying(50) NOT NULL, card_type character varying(50), card_last_four character varying(4), transaction_ref character varying(128), payment_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, status character varying(50) NOT NULL, staff_id_processed character varying(64), notes text, PRIMARY KEY (payment_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (staff_id_processed) REFERENCES hospitality_technology.staff(staff_id) )\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": "Count the total number of group chats."}, {"role": "assistant", "content": "SELECT COUNT(*) FROM social_media.conversations WHERE is_group_chat = 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.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.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) )\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": "List all customers who reside in New York and were created in the system before 2023."}, {"role": "assistant", "content": "SELECT customer_id, first_name, last_name, created_at FROM insurance.customers WHERE state = 'NY' AND created_at < '2023-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 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 )\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": "Show me projects that raised funds in 2022 and have a corresponding token held by CEXes on the 'Ethereum' chain. Display the project name, fundraising round name, investment value, the associated token symbol, and the total USD value of that token held by CEXes on Ethereum."}, {"role": "assistant", "content": "SELECT pfr.project_name, pfr.rounds_name, pfr.investment_value, ctb.token_symbol, SUM(ctb.usd_value) AS total_ethereum_cex_usd_value FROM project_fundraising_record AS pfr JOIN cex_token_balance AS ctb ON LOWER(pfr.project_name) LIKE '%' || LOWER(ctb.token_symbol) || '%' OR LOWER(ctb.token_symbol) LIKE '%' || LOWER(pfr.project_name) || '%' WHERE pfr.investment_date LIKE '2022%' AND ctb.chain = 'Ethereum' GROUP BY pfr.project_name, pfr.rounds_name, pfr.investment_value, ctb.token_symbol;"}, {"role": "user", "content": "Refine the results to only include projects where the fundraising investment value is greater than $1,000,000."}, {"role": "assistant", "content": "SELECT pfr.project_name, pfr.rounds_name, pfr.investment_value, ctb.token_symbol, SUM(ctb.usd_value) AS total_ethereum_cex_usd_value FROM project_fundraising_record AS pfr JOIN cex_token_balance AS ctb ON LOWER(pfr.project_name) LIKE '%' || LOWER(ctb.token_symbol) || '%' OR LOWER(ctb.token_symbol) LIKE '%' || LOWER(pfr.project_name) || '%' WHERE pfr.investment_date LIKE '2022%' AND ctb.chain = 'Ethereum' AND pfr.investment_value > 1000000 GROUP BY pfr.project_name, pfr.rounds_name, pfr.investment_value, ctb.token_symbol;"}, {"role": "user", "content": "Order the results by total USD value held by CEXes in descending order and show the top 5."}, {"role": "assistant", "content": "SELECT pfr.project_name, pfr.rounds_name, pfr.investment_value, ctb.token_symbol, SUM(ctb.usd_value) AS total_ethereum_cex_usd_value FROM project_fundraising_record AS pfr JOIN cex_token_balance AS ctb ON LOWER(pfr.project_name) LIKE '%' || LOWER(ctb.token_symbol) || '%' OR LOWER(ctb.token_symbol) LIKE '%' || LOWER(pfr.project_name) || '%' WHERE pfr.investment_date LIKE '2022%' AND ctb.chain = 'Ethereum' AND pfr.investment_value > 1000000 GROUP BY pfr.project_name, pfr.rounds_name, pfr.investment_value, ctb.token_symbol ORDER BY total_ethereum_cex_usd_value DESC LIMIT 5;"}, {"role": "user", "content": "Include the project's valuation from the fundraising record in the output."}, {"role": "assistant", "content": "SELECT pfr.project_name, pfr.rounds_name, pfr.investment_value, pfr.valuation, ctb.token_symbol, SUM(ctb.usd_value) AS total_ethereum_cex_usd_value FROM project_fundraising_record AS pfr JOIN cex_token_balance AS ctb ON LOWER(pfr.project_name) LIKE '%' || LOWER(ctb.token_symbol) || '%' OR LOWER(ctb.token_symbol) LIKE '%' || LOWER(pfr.project_name) || '%' WHERE pfr.investment_date LIKE '2022%' AND ctb.chain = 'Ethereum' AND pfr.investment_value > 1000000 GROUP BY pfr.project_name, pfr.rounds_name, pfr.investment_value, pfr.valuation, ctb.token_symbol ORDER BY total_ethereum_cex_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 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 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) )\n"}
{"conversations": [{"role": "user", "content": "For each guest, list reservation_id, guest_id, check_in_date, and the next reservation_id and its check_in_date."}, {"role": "assistant", "content": "SELECT r1.reservation_id,\n       r1.guest_id,\n       r1.check_in_date,\n       r2.reservation_id AS next_reservation_id,\n       r2.check_in_date   AS next_check_in_date\nFROM reservations r1\nLEFT JOIN reservations r2\n  ON r1.guest_id = r2.guest_id\n AND r2.check_in_date = (\n       SELECT MIN(check_in_date)\n       FROM reservations\n       WHERE guest_id = r1.guest_id\n         AND check_in_date > r1.check_in_date\n     );"}, {"role": "user", "content": "Only include guests who have at least two reservations."}, {"role": "assistant", "content": "SELECT r1.reservation_id,\n       r1.guest_id,\n       r1.check_in_date,\n       r2.reservation_id AS next_reservation_id,\n       r2.check_in_date   AS next_check_in_date\nFROM reservations r1\nLEFT JOIN reservations r2\n  ON r1.guest_id = r2.guest_id\n AND r2.check_in_date = (\n       SELECT MIN(check_in_date)\n       FROM reservations\n       WHERE guest_id = r1.guest_id\n         AND check_in_date > r1.check_in_date\n     )\nWHERE r1.guest_id IN (\n  SELECT guest_id\n  FROM reservations\n  GROUP BY guest_id\n  HAVING COUNT(*) >= 2\n);"}, {"role": "user", "content": "Also, only show next reservations that occur within 30 days of the current reservation."}, {"role": "assistant", "content": "SELECT r1.reservation_id,\n       r1.guest_id,\n       r1.check_in_date,\n       r2.reservation_id AS next_reservation_id,\n       r2.check_in_date   AS next_check_in_date\nFROM reservations r1\nLEFT JOIN reservations r2\n  ON r1.guest_id = r2.guest_id\n AND r2.check_in_date = (\n       SELECT MIN(check_in_date)\n       FROM reservations\n       WHERE guest_id = r1.guest_id\n         AND check_in_date > r1.check_in_date\n     )\n   AND r2.check_in_date <= r1.check_in_date + INTERVAL '30 days'\nWHERE r1.guest_id IN (\n  SELECT guest_id\n  FROM reservations\n  GROUP BY guest_id\n  HAVING COUNT(*) >= 2\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 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 )\n"}
{"conversations": [{"role": "user", "content": "Find any two claims made by the same customer on the same day. Return customer_id, the two claim IDs, and the incident date."}, {"role": "assistant", "content": "SELECT c1.customer_id,\n       c1.claim_id AS claim1_id,\n       c2.claim_id AS claim2_id,\n       DATE(c1.incident_date) AS incident_date\nFROM insurance.claims c1\nJOIN insurance.claims c2\n  ON c1.customer_id = c2.customer_id\n AND DATE(c1.incident_date) = DATE(c2.incident_date)\n AND c1.claim_id < c2.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.claims ( claim_id text, policy_id text, customer_id text, incident_date timestamp, reported_date timestamp, description text, estimated_loss numeric, status text, settlement_amount numeric, settlement_date date, claim_handler_id text, police_report_number text )\n"}
{"conversations": [{"role": "user", "content": "For each property, compute the average price and count of available services grouped by department."}, {"role": "assistant", "content": "SELECT p.property_id, p.property_name, s.department, COUNT(*) AS service_count, AVG(s.price) AS avg_price\nFROM hospitality_technology.services s\nJOIN hospitality_technology.properties p ON s.property_id = p.property_id\nWHERE s.is_available = true\nGROUP BY p.property_id, p.property_name, s.department;"}, {"role": "user", "content": "Now limit to departments with at least 5 available services and properties in the USA, ordering by avg_price descending."}, {"role": "assistant", "content": "SELECT p.property_id, p.property_name, s.department, COUNT(*) AS service_count, AVG(s.price) AS avg_price\nFROM hospitality_technology.services s\nJOIN hospitality_technology.properties p ON s.property_id = p.property_id\nWHERE s.is_available = true\n  AND p.country_code = 'USA'\nGROUP BY p.property_id, p.property_name, s.department\nHAVING COUNT(*) >= 5\nORDER BY avg_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 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.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)\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.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.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 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.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 )\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 clients along with their case_number and case_type for cases that are currently 'Open'."}, {"role": "assistant", "content": "SELECT c.first_name, c.last_name, c.email, cs.case_number, cs.case_type\nFROM legal_services.clients AS c\nJOIN legal_services.cases AS cs\n  ON c.client_id = cs.client_id\nWHERE cs.status = 'Open';"}], "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 character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, company_name character varying(200), email character varying(128) UNIQUE NOT NULL, phone character varying(32), address text, date_registered timestamp NOT NULL, status character varying(32) NOT NULL, PRIMARY KEY (client_id) )\nCREATE TABLE legal_services.lawyers ( lawyer_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, bar_number character varying(64) UNIQUE NOT NULL, firm_id character varying(64), email character varying(128) UNIQUE NOT NULL, phone character varying(32), specialization text, hire_date timestamp NOT NULL, is_partner boolean DEFAULT false, PRIMARY KEY (lawyer_id) )\nCREATE TABLE legal_services.law_firms ( firm_id character varying(64) NOT NULL, firm_name character varying(200) NOT NULL, address text NOT NULL, phone character varying(32), website character varying(255), founded_date date, managing_partner_id character varying(64), PRIMARY KEY (firm_id) )\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.documents ( document_id character varying(64) NOT NULL, case_id character varying(64) NOT NULL, document_name character varying(255) NOT NULL, document_type character varying(100), storage_path text NOT NULL, uploaded_by_lawyer_id character varying(64), upload_timestamp timestamp NOT NULL, version integer DEFAULT 1, description text, PRIMARY KEY (document_id) )\nCREATE TABLE legal_services.time_entries ( entry_id character varying(64) NOT NULL, case_id character varying(64) NOT NULL, lawyer_id character varying(64) NOT NULL, date_worked date NOT NULL, hours_spent numeric(5, 2) NOT NULL CHECK (hours_spent > 0), billing_rate numeric(10, 2) NOT NULL, description text NOT NULL, is_billable boolean DEFAULT true, is_billed boolean DEFAULT false, invoice_id character varying(64), created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (entry_id) )\nCREATE TABLE legal_services.appointments ( appointment_id character varying(64) NOT NULL, client_id character varying(64) NOT NULL, lawyer_id character varying(64) NOT NULL, case_id character varying(64), start_time timestamp NOT NULL, end_time timestamp NOT NULL, location text, subject character varying(255), notes text, status character varying(50) NOT NULL, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (appointment_id) )\n"}
{"conversations": [{"role": "user", "content": "Find all users who registered with a Yahoo email address, along with their registration dates."}, {"role": "assistant", "content": "SELECT user_id, username, email, password_hash FROM blockchain.users WHERE email LIKE '%@yahoo.com';"}, {"role": "user", "content": "This query doesn't show registration dates. Can you modify it to include the registration date?"}, {"role": "assistant", "content": "I notice the users table doesn't have a registration date column. Would you like me to show other available information from the users table?"}, {"role": "user", "content": "Then just show me the count of Yahoo email users instead."}, {"role": "assistant", "content": "SELECT COUNT(*) as yahoo_user_count FROM blockchain.users WHERE email LIKE '%@yahoo.com';"}], "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.blocks ( block_id text, previous_block_id text, timestamp timestamp, nonce integer, merkle_root text, difficulty integer )\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)\nCREATE TABLE blockchain.addresses ( address_id text PRIMARY KEY, public_key text, balance numeric )\nCREATE TABLE blockchain.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, PRIMARY KEY (user_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": "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": "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": "我想查看所有检查记录中检查员的ID和检查结果，同时统计每个检查员的检查次数。"}, {"role": "assistant", "content": "db.inspections.aggregate([\n  {\n    $group: {\n      _id: '$inspector_employee_id',\n      total_inspections: { $count: {} },\n      results: { $push: '$result' }\n    }\n  },\n  {\n    $project: {\n      inspector_employee_id: '$_id',\n      total_inspections: 1,\n      results: 1,\n      _id: 0\n    }\n  }\n]);"}, {"role": "user", "content": "如果我想只统计检查结果为'Fail'的次数，应该怎么改？"}, {"role": "assistant", "content": "db.inspections.aggregate([\n  {\n    $match: {\n      result: 'Fail'\n    }\n  },\n  {\n    $group: {\n      _id: '$inspector_employee_id',\n      failed_inspections: { $count: {} }\n    }\n  },\n  {\n    $project: {\n      inspector_employee_id: '$_id',\n      failed_inspections: 1,\n      _id: 0\n    }\n  }\n]);"}], "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\nCollection 'inspections'. Document structure: { _id: <ObjectId (or inspection_id)>, inspection_id: String, build_id: String (reference), component_id: String (reference, optional), step_id: String (reference, optional), inspection_type: String, inspector_employee_id: String (reference), inspection_timestamp: ISODate, result: String, remarks: String }. Required: inspection_id, build_id, inspection_type, inspector_employee_id, inspection_timestamp, result. Indexes on build_id, component_id, step_id, inspector_employee_id, result.\n"}
{"conversations": [{"role": "user", "content": "Retrieve each passenger's full name, their email, booking status, and the name of the origin location for all bookings."}, {"role": "assistant", "content": "SELECT p.first_name || ' ' || p.last_name AS full_name, p.email, b.status, l.name AS origin_location_name\nFROM transportation.bookings b\nJOIN transportation.passengers p ON b.passenger_id = p.passenger_id\nJOIN transportation.trips t ON b.trip_id = t.trip_id\nJOIN transportation.locations l ON t.origin_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.trips ( trip_id character varying(64) NOT NULL, route_id character varying(64), vehicle_id character varying(64) NOT NULL, driver_id character varying(64) NOT NULL, scheduled_departure timestamp with time zone NOT NULL, actual_departure timestamp with time zone, scheduled_arrival timestamp with time zone NOT NULL, actual_arrival timestamp with time zone, origin_location_id character varying(64) NOT NULL, destination_location_id character varying(64) NOT NULL, status character varying(32) NOT NULL, passenger_count integer, cargo_manifest_id character varying(64), PRIMARY KEY (trip_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.passengers ( passenger_id character varying(64) NOT NULL, first_name character varying(128) NOT NULL, last_name character varying(128) NOT NULL, email character varying(128) UNIQUE, phone_number character varying(32) UNIQUE, date_of_birth date, loyalty_program_id character varying(64), created_at timestamp with time zone NOT NULL, PRIMARY KEY (passenger_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 me all insurance plans that have more than 5 patients enrolled as their primary insurance, along with the provider name and count of patients."}, {"role": "assistant", "content": "SELECT ip.plan_id, ip.plan_name, ip.insurance_provider, 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, ip.plan_name, ip.insurance_provider HAVING COUNT(pi.patient_id) > 5 ORDER BY patient_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.doctors ( doctor_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, specialty character varying(100) NOT NULL, license_number character varying(50) UNIQUE NOT NULL, phone_number character varying(20), email character varying(128) UNIQUE, hospital_affiliation_id character varying(64), created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (doctor_id) )\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.diagnoses ( diagnosis_id character varying(64) NOT NULL, record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, diagnosis_code character varying(20) NOT NULL, code_type character varying(10) NOT NULL DEFAULT 'ICD-10', description text, diagnosis_date date NOT NULL, status character varying(32) NOT NULL, is_chronic boolean DEFAULT false, PRIMARY KEY (diagnosis_id) )\nCREATE TABLE healthcare.medications ( medication_id character varying(64) NOT NULL, medication_name character varying(255) NOT NULL, generic_name character varying(255), manufacturer character varying(100), ndc_code character varying(20) UNIQUE, description text, PRIMARY KEY (medication_id) )\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 ( plan_id character varying(64) NOT NULL, plan_name character varying(200) NOT NULL, insurance_provider character varying(100) NOT NULL, plan_type character varying(50), contact_phone character varying(20), website character varying(255), PRIMARY KEY (plan_id) )\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": "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": "Find cases where an address received tokens in one transfer and then sent tokens in another. List the receive transfer_id, the send transfer_id, the address, and both transfer values."}, {"role": "assistant", "content": "SELECT recv.transfer_id AS receive_transfer_id,\n       send.transfer_id AS send_transfer_id,\n       recv.to_address AS address,\n       recv.value       AS received_value,\n       send.value       AS sent_value\nFROM web3.token_transfers recv\nJOIN web3.token_transfers send\n  ON recv.to_address = send.from_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.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)\n"}
{"conversations": [{"role": "user", "content": "Show me all locations in California that are of type 'gas station', including their name, city, and postal code."}, {"role": "assistant", "content": "SELECT name, city, postal_code FROM transportation.locations WHERE state_province = 'California' AND type = 'gas station';"}, {"role": "user", "content": "Now filter these results to only show gas stations in Los Angeles, and include their full address."}, {"role": "assistant", "content": "SELECT name, city, postal_code, address_line1 FROM transportation.locations WHERE state_province = 'California' AND type = 'gas station' AND city = 'Los Angeles';"}, {"role": "user", "content": "Can you also include the latitude and longitude coordinates, and order the results by postal code in ascending order?"}, {"role": "assistant", "content": "SELECT name, city, postal_code, address_line1, latitude, longitude FROM transportation.locations WHERE state_province = 'California' AND type = 'gas station' AND city = 'Los Angeles' ORDER BY postal_code 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.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 )\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": "Find appointments that are longer than 30 minutes."}, {"role": "assistant", "content": "SELECT * FROM legal_services.appointments WHERE end_time IS NOT NULL AND start_time IS NOT NULL AND end_time > start_time + INTERVAL '30 minutes'"}], "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": "List all wallets holding the NFT with contract_address '0xabc123' and token_id '100' and the amount held."}, {"role": "assistant", "content": "SELECT wallet_address, amount\nFROM nft_holders\nWHERE contract_address = '0xabc123'\n  AND token_id = '100';"}, {"role": "user", "content": "Also include the NFT name from nft_metadata by joining on contract_address and token_id."}, {"role": "assistant", "content": "SELECT nh.wallet_address,\n       nh.amount,\n       nm.name\nFROM nft_holders nh\nJOIN nft_metadata nm ON nh.contract_address = nm.contract_address\n                   AND nh.token_id = nm.token_id\nWHERE nh.contract_address = '0xabc123'\n  AND nh.token_id = '100';"}, {"role": "user", "content": "Finally, add the collection name from nft_collections where blockchain is 'Ethereum'."}, {"role": "assistant", "content": "SELECT nh.wallet_address,\n       nh.amount,\n       nm.name,\n       nc.name AS collection_name\nFROM nft_holders nh\nJOIN nft_metadata nm ON nh.contract_address = nm.contract_address\n                   AND nh.token_id = nm.token_id\nJOIN nft_collections nc ON nh.contract_address = nc.contract_address\n                      AND nc.blockchain = 'Ethereum'\nWHERE nh.contract_address = '0xabc123'\n  AND nh.token_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 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 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 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 ( 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 varchar NOT NULL, status varchar NOT NULL, collection_type varchar NOT NULL, package_id varchar NOT NULL, previous_transaction varchar NOT NULL, display varchar NOT NULL, owner varchar NOT NULL, name varchar 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_balances ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar 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 ( 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 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_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(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 )\n"}
{"conversations": [{"role": "user", "content": "Count the number of completed premium payments grouped by payment_method."}, {"role": "assistant", "content": "SELECT payment_method,\n       COUNT(*) AS payment_count\nFROM insurance.premium_payments\nWHERE status = 'Completed'\nGROUP BY payment_method;"}], "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 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 revenue generated by ticket sales at the station with ID 'ST101' for the past month?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information on the revenue generated by ticket sales as this data is not available in the current database table. The table only contains details about station information such as name, location, and platform count. If you have another question or need assistance with something else related to the station data, 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.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": "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": "Show me the total transaction amount sent by each sender address, along with their current balance from the addresses table."}, {"role": "assistant", "content": "SELECT t.sender_address, SUM(t.amount) AS total_sent, a.balance FROM blockchain.transactions t JOIN blockchain.addresses a ON t.sender_address = a.address_id GROUP BY t.sender_address, a.balance;"}, {"role": "user", "content": "Now filter this to only show sender addresses that have sent more than 1000 in total and have a balance greater than 500."}, {"role": "assistant", "content": "SELECT t.sender_address, SUM(t.amount) AS total_sent, a.balance FROM blockchain.transactions t JOIN blockchain.addresses a ON t.sender_address = a.address_id GROUP BY t.sender_address, a.balance HAVING SUM(t.amount) > 1000 AND a.balance > 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 blockchain.blocks ( block_id text PRIMARY KEY, previous_block_id text, timestamp timestamp, nonce int, merkle_root text, difficulty int )\nCREATE TABLE blockchain.transactions ( transaction_id text PRIMARY KEY, block_id text, sender_address text, receiver_address text, amount numeric, timestamp timestamp, signature text )\nCREATE TABLE blockchain.addresses ( address_id text PRIMARY KEY, public_key text, balance numeric )\nCREATE TABLE blockchain.nodes ( node_id text PRIMARY KEY, ip_address text, port int, last_seen timestamp )\nCREATE TABLE blockchain.users ( user_id text PRIMARY KEY, username text, email text, password_hash text )\nCREATE TABLE blockchain.smart_contracts ( contract_id text PRIMARY KEY, creator_address text, code text, timestamp timestamp )\n"}
{"conversations": [{"role": "user", "content": "For projects that have completed more than one fundraising round, calculate the average investment value across all their recorded rounds. Display the project name and this average value."}, {"role": "assistant", "content": "SELECT project_name, AVG(investment_value) AS average_investment FROM project_fundraising_record GROUP BY project_name HAVING COUNT(*) > 1;"}, {"role": "user", "content": "Can you modify this to only show projects where the average investment value is greater than 10 million USD and order the results by average investment value descending?"}, {"role": "assistant", "content": "SELECT project_name, AVG(investment_value) AS average_investment FROM project_fundraising_record GROUP BY project_name HAVING COUNT(*) > 1 AND AVG(investment_value) > 10000000 ORDER BY average_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,  -- 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 )\n"}
{"conversations": [{"role": "user", "content": "Find all documents of type 'Correspondence' uploaded in 2023. Show the document name, upload timestamp, and the name of the case it belongs to."}, {"role": "assistant", "content": "SELECT T1.document_name, T1.upload_timestamp, T2.case_name FROM legal_services.documents AS T1 JOIN legal_services.cases AS T2 ON T1.case_id = T2.case_id WHERE T1.document_type = 'Correspondence' AND EXTRACT(YEAR FROM T1.upload_timestamp) = 2023;"}, {"role": "user", "content": "Now, only show the documents for cases handled by lawyer with ID 'lawyer_001'."}, {"role": "assistant", "content": "SELECT T1.document_name, T1.upload_timestamp, T2.case_name FROM legal_services.documents AS T1 JOIN legal_services.cases AS T2 ON T1.case_id = T2.case_id WHERE T1.document_type = 'Correspondence' AND EXTRACT(YEAR FROM T1.upload_timestamp) = 2023 AND T2.lead_lawyer_id = 'lawyer_001';"}, {"role": "user", "content": "Additionally, include the first and last name of the lawyer who actually uploaded the document, and sort the results by upload timestamp descending."}, {"role": "assistant", "content": "SELECT T1.document_name, T1.upload_timestamp, T2.case_name, T3.first_name, T3.last_name FROM legal_services.documents AS T1 JOIN legal_services.cases AS T2 ON T1.case_id = T2.case_id JOIN legal_services.lawyers AS T3 ON T1.uploaded_by_lawyer_id = T3.lawyer_id WHERE T1.document_type = 'Correspondence' AND EXTRACT(YEAR FROM T1.upload_timestamp) = 2023 AND T2.lead_lawyer_id = 'lawyer_001' ORDER BY T1.upload_timestamp 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.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.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.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.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": "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": "List all users whose usernames start with the letter 'B'."}, {"role": "assistant", "content": "SELECT user_id, username, email, created_at FROM trading_platform.users WHERE username LIKE 'B%';"}, {"role": "user", "content": "Can you make it case-insensitive, so usernames starting with either upper or lower case 'b' are included?"}, {"role": "assistant", "content": "SELECT user_id, username, email, created_at FROM trading_platform.users WHERE username ILIKE 'b%';"}, {"role": "user", "content": "Instead of showing all details, just display the usernames in alphabetical order."}, {"role": "assistant", "content": "SELECT username FROM trading_platform.users WHERE username ILIKE 'b%' ORDER BY username ASC;"}, {"role": "user", "content": "Limit the result to only the first 3 usernames."}, {"role": "assistant", "content": "SELECT username FROM trading_platform.users WHERE username ILIKE 'b%' ORDER BY username ASC 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 trading_platform.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": "For each claim handler, count the number of documents uploaded for the claims they handled. Return claim_handler_id and document_count."}, {"role": "assistant", "content": "SELECT c.claim_handler_id,\n       COUNT(d.document_id) AS document_count\nFROM insurance.claims AS c\nJOIN insurance.claim_documents AS d\n  ON c.claim_id = d.claim_id\nGROUP BY c.claim_handler_id;"}, {"role": "user", "content": "Now restrict to handlers who have uploaded more than 10 documents."}, {"role": "assistant", "content": "SELECT c.claim_handler_id,\n       COUNT(d.document_id) AS document_count\nFROM insurance.claims AS c\nJOIN insurance.claim_documents AS d\n  ON c.claim_id = d.claim_id\nGROUP BY c.claim_handler_id\nHAVING COUNT(d.document_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 insurance.claims ( claim_id.text, policy_id.text, customer_id.text, incident_date.timestamp, reported_date.timestamp, description.text, estimated_loss.numeric, status.text, settlement_amount.numeric, settlement_date.date, claim_handler_id.text, police_report_number.text )\nCREATE TABLE insurance.premium_payments ( payment_id character varying(64) NOT NULL, policy_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, payment_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, amount_paid numeric(12, 2) NOT NULL, payment_method character varying(50), transaction_reference character varying(128) UNIQUE, due_date date, payment_period_start date, payment_period_end date, status character varying(30) NOT NULL DEFAULT 'Completed', PRIMARY KEY (payment_id) )\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": "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": "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 me all pairs of overlapping reservations at the same property, including both reservation IDs."}, {"role": "assistant", "content": "SELECT r1.reservation_id AS res1, r2.reservation_id AS res2\nFROM hospitality_technology.reservations r1\nJOIN hospitality_technology.reservations r2\n  ON r1.property_id = r2.property_id\n  AND r1.reservation_id < r2.reservation_id\n  AND r1.check_in_date < r2.check_out_date\n  AND r1.check_out_date > r2.check_in_date;"}, {"role": "user", "content": "Actually, only include overlaps longer than 1 day and order by the overlap duration descending."}, {"role": "assistant", "content": "SELECT r1.reservation_id AS res1,\n       r2.reservation_id AS res2,\n       (LEAST(r1.check_out_date, r2.check_out_date) - GREATEST(r1.check_in_date, r2.check_in_date)) AS overlap_days\nFROM hospitality_technology.reservations r1\nJOIN hospitality_technology.reservations r2\n  ON r1.property_id = r2.property_id\n  AND r1.reservation_id < r2.reservation_id\n  AND r1.check_in_date < r2.check_out_date\n  AND r1.check_out_date > r2.check_in_date\nWHERE (LEAST(r1.check_out_date, r2.check_out_date) - GREATEST(r1.check_in_date, r2.check_in_date)) > 1\nORDER BY overlap_days 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.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 )\n"}
{"conversations": [{"role": "user", "content": "List all users who joined after May 1, 2024."}, {"role": "assistant", "content": "SELECT user_id, username, email, full_name, created_at\nFROM social_media.users\nWHERE 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.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.likes ( like_id text, user_id text, post_id text, comment_id text, created_at timestamp )\nCREATE TABLE social_media.follows ( follow_id character varying(64) NOT NULL, follower_user_id character varying(64) NOT NULL, following_user_id character varying(64) NOT NULL, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (follow_id), CONSTRAINT unique_follow UNIQUE (follower_user_id, following_user_id) )\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 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.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": "Find pairs of achievements within each game where the point difference is exactly 10."}, {"role": "assistant", "content": "SELECT a1.achievement_id AS ach1_id,\n       a2.achievement_id AS ach2_id,\n       ABS(a1.points - a2.points) AS point_diff\nFROM gaming_technology.achievements a1\nJOIN gaming_technology.achievements a2\n  ON a1.game_id = a2.game_id\nWHERE a1.achievement_id < a2.achievement_id\n  AND ABS(a1.points - a2.points) = 10;"}, {"role": "user", "content": "Include the game_id and show both achievement names labeled ach1 and ach2."}, {"role": "assistant", "content": "SELECT a1.game_id,\n       a1.name AS ach1_name,\n       a2.name AS ach2_name,\n       ABS(a1.points - a2.points) AS point_diff\nFROM gaming_technology.achievements a1\nJOIN gaming_technology.achievements a2\n  ON a1.game_id = a2.game_id\nWHERE a1.achievement_id < a2.achievement_id\n  AND ABS(a1.points - a2.points) = 10;"}, {"role": "user", "content": "Now restrict to pairs where both achievements are visible and the difference is at least 15."}, {"role": "assistant", "content": "SELECT a1.game_id,\n       a1.name AS ach1_name,\n       a2.name AS ach2_name,\n       ABS(a1.points - a2.points) AS point_diff\nFROM gaming_technology.achievements a1\nJOIN gaming_technology.achievements a2\n  ON a1.game_id = a2.game_id\nWHERE a1.achievement_id < a2.achievement_id\n  AND a1.hidden = FALSE\n  AND a2.hidden = FALSE\n  AND ABS(a1.points - a2.points) >= 15;"}, {"role": "user", "content": "Order the result by game_id ascending and point_diff descending."}, {"role": "assistant", "content": "SELECT a1.game_id,\n       a1.name AS ach1_name,\n       a2.name AS ach2_name,\n       ABS(a1.points - a2.points) AS point_diff\nFROM gaming_technology.achievements a1\nJOIN gaming_technology.achievements a2\n  ON a1.game_id = a2.game_id\nWHERE a1.achievement_id < a2.achievement_id\n  AND a1.hidden = FALSE\n  AND a2.hidden = FALSE\n  AND ABS(a1.points - a2.points) >= 15\nORDER BY a1.game_id ASC,\n         point_diff 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.achievements ( achievement_id.uuid, game_id.uuid, name.text, description.text, icon_url.text, points.integer, hidden.boolean )\n"}
{"conversations": [{"role": "user", "content": "Show me each service order along with the next order placed by the same guest, including both order IDs and the time difference in minutes between the two orders."}, {"role": "assistant", "content": "SELECT a.order_id,\n       b.order_id AS next_order_id,\n       EXTRACT(EPOCH FROM (b.order_timestamp - a.order_timestamp)) / 60 AS diff_minutes\nFROM hospitality_technology.service_orders a\nJOIN hospitality_technology.service_orders b\n  ON a.guest_id = b.guest_id\n AND b.order_timestamp > a.order_timestamp;"}], "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.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 )\n"}
{"conversations": [{"role": "user", "content": "Find all users whose usernames contain numbers and have email addresses from either Gmail or Yahoo."}, {"role": "assistant", "content": "SELECT username, email FROM blockchain.users WHERE (username ~ '[0-9]') AND (email LIKE '%@gmail.com' OR email LIKE '%@yahoo.com');"}, {"role": "user", "content": "Now, order these results by username length in descending order."}, {"role": "assistant", "content": "SELECT username, email FROM blockchain.users WHERE (username ~ '[0-9]') AND (email LIKE '%@gmail.com' OR email LIKE '%@yahoo.com') ORDER BY LENGTH(username) DESC;"}, {"role": "user", "content": "Can you modify this to only show the top 5 longest usernames?"}, {"role": "assistant", "content": "SELECT username, email FROM blockchain.users WHERE (username ~ '[0-9]') AND (email LIKE '%@gmail.com' OR email LIKE '%@yahoo.com') ORDER BY LENGTH(username) 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.users ( user_id text, username text, email text, password_hash text )\n"}
{"conversations": [{"role": "user", "content": "Show each route's route_id and the total number of completed trips associated with it."}, {"role": "assistant", "content": "SELECT route_id, COUNT(*) AS completed_trip_count\nFROM transportation.trips\nWHERE status = 'Completed'\nGROUP BY route_id;"}, {"role": "user", "content": "Now, only include routes with more than 5 completed trips and order by completed_trip_count descending."}, {"role": "assistant", "content": "SELECT route_id, COUNT(*) AS completed_trip_count\nFROM transportation.trips\nWHERE status = 'Completed'\nGROUP BY route_id\nHAVING COUNT(*) > 5\nORDER BY completed_trip_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 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.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.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": "What is the maintenance schedule for the platforms at the station with ID 'ST234' for the next month?"}, {"role": "assistant", "content": "I'm sorry, but I don't have access to the maintenance schedule for the platforms at any station. The data I have only includes basic station information such as station ID, name, location, and number of platforms. For maintenance schedules, you may need to contact the station management or 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.stations ( station_id text PRIMARY KEY, station_name text, city text, state_province text, country_code text, address text, timezone text, number_of_platforms int, created_at timestamp, last_updated_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Find all distinct pairs of customers having the same first_name but living in different cities. Display a.customer_id, a.first_name, a.city AS city_a, b.customer_id, b.city AS city_b."}, {"role": "assistant", "content": "SELECT a.customer_id AS customer_id_a,\n       a.first_name,\n       a.city      AS city_a,\n       b.customer_id AS customer_id_b,\n       b.city      AS city_b\nFROM financial_services.customers a\nJOIN financial_services.customers b\n  ON a.first_name = b.first_name\n AND a.city <> b.city\n AND a.customer_id < b.customer_id;"}, {"role": "user", "content": "Only include pairs where both customers have status 'Active'."}, {"role": "assistant", "content": "SELECT a.customer_id AS customer_id_a,\n       a.first_name,\n       a.city      AS city_a,\n       b.customer_id AS customer_id_b,\n       b.city      AS city_b\nFROM financial_services.customers a\nJOIN financial_services.customers b\n  ON a.first_name = b.first_name\n AND a.city <> b.city\n AND a.customer_id < b.customer_id\nWHERE a.status = 'Active'\n  AND b.status = 'Active';"}, {"role": "user", "content": "Sort the output by first_name ascending and then by customer_id_a ascending."}, {"role": "assistant", "content": "SELECT a.customer_id AS customer_id_a,\n       a.first_name,\n       a.city      AS city_a,\n       b.customer_id AS customer_id_b,\n       b.city      AS city_b\nFROM financial_services.customers a\nJOIN financial_services.customers b\n  ON a.first_name = b.first_name\n AND a.city <> b.city\n AND a.customer_id < b.customer_id\nWHERE a.status = 'Active'\n  AND b.status = 'Active'\nORDER BY a.first_name ASC,\n         customer_id_a 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 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 )\n"}
{"conversations": [{"role": "user", "content": "List all claims and the first and last name of the agent who handled each claim."}, {"role": "assistant", "content": "SELECT T1.claim_id, T1.estimated_loss, T2.first_name, T2.last_name FROM claims AS T1 JOIN agents AS T2 ON T1.claim_handler_id = T2.agent_id"}, {"role": "user", "content": "Can you also include the policy ID and customer ID for each claim?"}, {"role": "assistant", "content": "SELECT T1.claim_id, T1.policy_id, T1.customer_id, T1.estimated_loss, T2.first_name, T2.last_name FROM claims AS T1 JOIN agents AS T2 ON T1.claim_handler_id = T2.agent_id"}, {"role": "user", "content": "Filter the results to only show claims where the status is 'Open' and the agent is currently 'active'."}, {"role": "assistant", "content": "SELECT T1.claim_id, T1.policy_id, T1.customer_id, T1.estimated_loss, T2.first_name, T2.last_name FROM claims AS T1 JOIN agents AS T2 ON T1.claim_handler_id = T2.agent_id WHERE T1.status = 'Open' AND T2.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 insurance.claims ( claim_id.text, policy_id.text, customer_id.text, incident_date.timestamp, reported_date.timestamp, description.text, estimated_loss.numeric, status.text, settlement_amount.numeric, settlement_date.date, claim_handler_id.text, police_report_number.text )\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 ( 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 )\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 )\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": "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": "How many lawyers who are partners were hired in each year? Show the hire year and the count."}, {"role": "assistant", "content": "SELECT strftime('%Y', hire_date) AS hire_year ,  count(lawyer_id) FROM legal_services.lawyers WHERE is_partner  =  true GROUP BY hire_year"}], "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": "List all premium payments for policy 'POL123'. Show payment ID, payment date, amount paid, and status."}, {"role": "assistant", "content": "SELECT payment_id, payment_date, amount_paid, status FROM insurance.premium_payments WHERE policy_id = 'POL123';"}, {"role": "user", "content": "Only show payments made on or after January 1, 2024."}, {"role": "assistant", "content": "SELECT payment_id, payment_date, amount_paid, status FROM insurance.premium_payments WHERE policy_id = 'POL123' AND payment_date >= '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 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)\n"}
{"conversations": [{"role": "user", "content": "List all individual token holdings by CEX addresses on the 'Arbitrum' chain with a USD value greater than $100,000. Show the exchange, token symbol, and USD value."}, {"role": "assistant", "content": "SELECT exchange, token_symbol, usd_value FROM cex_token_balance WHERE chain = 'Arbitrum' AND usd_value > 100000;"}, {"role": "user", "content": "Can you calculate the total USD value held by all CEXes for *each token* on the 'Arbitrum' chain, considering only holdings greater than $100,000? Show the token symbol and the total USD value."}, {"role": "assistant", "content": "SELECT token_symbol, SUM(usd_value) AS total_usd_value FROM cex_token_balance WHERE chain = 'Arbitrum' AND usd_value > 100000 GROUP BY token_symbol;"}, {"role": "user", "content": "Now, join this with the basic info table to include the token's narrative and its current price."}, {"role": "assistant", "content": "SELECT aggregated_cex.token_symbol, aggregated_cex.total_usd_value, tbi.narrative, tbi.price AS current_price FROM ( SELECT token_symbol, SUM(usd_value) AS total_usd_value FROM cex_token_balance WHERE chain = 'Arbitrum' AND usd_value > 100000 GROUP BY token_symbol ) AS aggregated_cex JOIN token_basic_info AS tbi ON aggregated_cex.token_symbol = tbi.token_symbol AND 'Arbitrum' = tbi.chain;"}, {"role": "user", "content": "Filter these results to only show tokens belonging to the 'DeFi' or 'AI' narratives and order by total USD value descending, showing the top 5."}, {"role": "assistant", "content": "SELECT aggregated_cex.token_symbol, aggregated_cex.total_usd_value, tbi.narrative, tbi.price AS current_price FROM ( SELECT token_symbol, SUM(usd_value) AS total_usd_value FROM cex_token_balance WHERE chain = 'Arbitrum' AND usd_value > 100000 GROUP BY token_symbol ) AS aggregated_cex JOIN token_basic_info AS tbi ON aggregated_cex.token_symbol = tbi.token_symbol AND 'Arbitrum' = tbi.chain WHERE tbi.narrative IN ('DeFi', 'AI') ORDER BY aggregated_cex.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 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 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.text, chain.text, address.text, exchange.text, token_address.text, token_symbol.text, balance.numeric, usd_value.numeric, price.numeric )\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 )\n"}
{"conversations": [{"role": "user", "content": "List the total number of items acquired by each player, grouped by rarity, for items that have been acquired at least twice."}, {"role": "assistant", "content": "SELECT pi.player_id, igi.rarity, SUM(pi.quantity) AS total_acquired\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.in_game_items igi ON pi.item_id = igi.item_id\nGROUP BY pi.player_id, igi.rarity\nHAVING SUM(pi.quantity) >= 2;"}, {"role": "user", "content": "Also show only rarities that are 'Epic' or 'Legendary'."}, {"role": "assistant", "content": "SELECT pi.player_id, igi.rarity, SUM(pi.quantity) AS total_acquired\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.in_game_items igi ON pi.item_id = igi.item_id\nWHERE igi.rarity IN ('Epic', 'Legendary')\nGROUP BY pi.player_id, igi.rarity\nHAVING SUM(pi.quantity) >= 2;"}, {"role": "user", "content": "Can you also include the most recent acquisition date for each (player, rarity) pair?"}, {"role": "assistant", "content": "SELECT pi.player_id, igi.rarity, SUM(pi.quantity) AS total_acquired, MAX(pi.acquired_at) AS last_acquired_at\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.in_game_items igi ON pi.item_id = igi.item_id\nWHERE igi.rarity IN ('Epic', 'Legendary')\nGROUP BY pi.player_id, igi.rarity\nHAVING SUM(pi.quantity) >= 2;"}, {"role": "user", "content": "Sort the result by total_acquired descending, then by last_acquired_at descending."}, {"role": "assistant", "content": "SELECT pi.player_id, igi.rarity, SUM(pi.quantity) AS total_acquired, MAX(pi.acquired_at) AS last_acquired_at\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.in_game_items igi ON pi.item_id = igi.item_id\nWHERE igi.rarity IN ('Epic', 'Legendary')\nGROUP BY pi.player_id, igi.rarity\nHAVING SUM(pi.quantity) >= 2\nORDER BY total_acquired DESC, last_acquired_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 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, 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 )\nCREATE TABLE gaming_technology.player_inventory ( inventory_id.uuid, player_id.uuid, item_id.uuid, quantity.integer, acquired_at.timestamptz, instance_data.jsonb )\n"}
{"conversations": [{"role": "user", "content": "List the user ID, theme, and updated_at for users who have updated their settings in the last 90 days and have their theme set to 'dark'."}, {"role": "assistant", "content": "SELECT user_id, theme, updated_at FROM social_media.user_settings WHERE updated_at >= NOW() - INTERVAL '90 days' AND theme = 'dark';"}, {"role": "user", "content": "Refine the list to only show users who have also disabled push notifications."}, {"role": "assistant", "content": "SELECT user_id, theme, updated_at FROM social_media.user_settings WHERE updated_at >= NOW() - INTERVAL '90 days' AND theme = 'dark' AND push_notifications_enabled = 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 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": "For each narrative in token_basic_info, compute the total liquidity and count of tokens from token_dexpool_info. Show narrative, total_liquidity, and token_count."}, {"role": "assistant", "content": "SELECT tbi.narrative,\n  SUM(td.liquidity) AS total_liquidity,\n  COUNT(DISTINCT td.token_symbol) AS token_count\nFROM token_basic_info tbi\nJOIN token_dexpool_info td\n  ON tbi.token_address = td.token_address\nGROUP BY tbi.narrative;"}, {"role": "user", "content": "Include only tokens where volume_24h > 500000 and price_change_percentage_6h > 0."}, {"role": "assistant", "content": "SELECT tbi.narrative,\n  SUM(td.liquidity) AS total_liquidity,\n  COUNT(DISTINCT td.token_symbol) AS token_count\nFROM token_basic_info tbi\nJOIN token_dexpool_info td\n  ON tbi.token_address = td.token_address\nWHERE td.volume_24h > 500000\n  AND td.price_change_percentage_6h > 0\nGROUP BY tbi.narrative;"}, {"role": "user", "content": "Now join narrative_info to also get trend_rank and narrative volume_24h."}, {"role": "assistant", "content": "SELECT tbi.narrative,\n  ni.trend_rank,\n  ni.volume_24h AS narrative_volume,\n  SUM(td.liquidity) AS total_liquidity,\n  COUNT(DISTINCT td.token_symbol) AS token_count\nFROM token_basic_info tbi\nJOIN token_dexpool_info td\n  ON tbi.token_address = td.token_address\nJOIN narrative_info ni\n  ON tbi.narrative = ni.narrative\nWHERE td.volume_24h > 500000\n  AND td.price_change_percentage_6h > 0\nGROUP BY tbi.narrative, ni.trend_rank, ni.volume_24h;"}, {"role": "user", "content": "Finally, only keep narratives where trend_rank <= 10 and order by total_liquidity descending."}, {"role": "assistant", "content": "SELECT tbi.narrative,\n  ni.trend_rank,\n  ni.volume_24h AS narrative_volume,\n  SUM(td.liquidity) AS total_liquidity,\n  COUNT(DISTINCT td.token_symbol) AS token_count\nFROM token_basic_info tbi\nJOIN token_dexpool_info td\n  ON tbi.token_address = td.token_address\nJOIN narrative_info ni\n  ON tbi.narrative = ni.narrative\nWHERE td.volume_24h > 500000\n  AND td.price_change_percentage_6h > 0\n  AND ni.trend_rank <= 10\nGROUP BY tbi.narrative, ni.trend_rank, ni.volume_24h\nORDER BY total_liquidity 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": "Can you list the names of agencies that do not have a parent agency assigned, ordered by their established date?"}, {"role": "assistant", "content": "SELECT agency_id, agency_name, established_date\nFROM government_services.agencies\nWHERE parent_agency_id IS NULL\nORDER BY established_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.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 )\n"}
{"conversations": [{"role": "user", "content": "List diagnoses and the name of any medication mentioned in the treatment plan of the associated medical record. Show diagnosis ID, diagnosis description, medication name, and record ID."}, {"role": "assistant", "content": "SELECT T1.diagnosis_id, T1.description, T3.medication_name, T2.record_id FROM healthcare.diagnoses AS T1 JOIN healthcare.medical_records AS T2 ON T1.record_id = T2.record_id JOIN healthcare.medications AS T3 ON T2.treatment_plan LIKE '%' || T3.medication_name || '%';"}, {"role": "user", "content": "Refine this list to only include diagnoses marked as chronic."}, {"role": "assistant", "content": "SELECT T1.diagnosis_id, T1.description, T3.medication_name, T2.record_id FROM healthcare.diagnoses AS T1 JOIN healthcare.medical_records AS T2 ON T1.record_id = T2.record_id JOIN healthcare.medications AS T3 ON T2.treatment_plan LIKE '%' || T3.medication_name || '%' WHERE T1.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.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 ( doctor_id text PRIMARY KEY, first_name text, last_name text, specialty text, license_number text, phone_number text, email text, hospital_affiliation_id text, created_at timestamp, updated_at timestamp )\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 ( record_id.text, patient_id.text, appointment_id.text, doctor_id.text, record_date.timestamp, chief_complaint.text, present_illness_history.text, past_medical_history.text, physical_examination_notes.text, assessment.text, treatment_plan.text, vitals.json, created_at.timestamp )\nCREATE TABLE healthcare.diagnoses ( diagnosis_id character varying(64) NOT NULL, record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, diagnosis_code character varying(20) NOT NULL, code_type character varying(10) NOT NULL DEFAULT 'ICD-10', description text, diagnosis_date date NOT NULL, status character varying(32) NOT NULL, is_chronic boolean DEFAULT false, PRIMARY KEY (diagnosis_id) )\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.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )\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": "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": "Could you show me the usernames of users who have received likes on their posts, along with the total number of likes each user's posts have received?"}, {"role": "assistant", "content": "SELECT T1.username, count(T3.like_id) AS total_likes_received FROM social_media.users AS T1 JOIN social_media.posts AS T2 ON T1.user_id = T2.user_id JOIN social_media.likes AS T3 ON T2.post_id = T3.post_id GROUP BY T1.username;"}, {"role": "user", "content": "Okay, now could you filter this to only include users who have received more than 5 likes across their posts, and order the results by the number of likes in descending order?"}, {"role": "assistant", "content": "SELECT T1.username, count(T3.like_id) AS total_likes_received FROM social_media.users AS T1 JOIN social_media.posts AS T2 ON T1.user_id = T2.user_id JOIN social_media.likes AS T3 ON T2.post_id = T3.post_id GROUP BY T1.username HAVING count(T3.like_id) > 5 ORDER BY total_likes_received 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 social_media.users (\n    user_id character varying(64) NOT NULL,  -- unique identifier for the user\n    username character varying(50) NOT NULL UNIQUE, -- user's unique handle\n    email character varying(128) NOT NULL UNIQUE, -- user's email address\n    password_hash text NOT NULL, -- hashed password\n    full_name character varying(100), -- user's full name\n    profile_picture_url text, -- URL to the profile picture\n    bio text, -- short user biography\n    location character varying(100), -- user's location\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of account creation\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last profile update\n    is_verified boolean NOT NULL DEFAULT false, -- verification status\n    PRIMARY KEY (user_id)\n)\nCREATE TABLE social_media.posts (\n    post_id character varying(64) NOT NULL, -- unique identifier for the post\n    user_id character varying(64) NOT NULL, -- identifier of the user who created the post (FK to users.user_id)\n    content text, -- textual content of the post\n    media_url text, -- URL to attached media (image/video)\n    media_type character varying(20), -- type of media ('image', 'video', null)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of post creation\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last post edit\n    visibility character varying(20) NOT NULL DEFAULT 'public', -- visibility ('public', 'friends', 'private')\n    location_lat numeric(9,6), -- latitude of post location\n    location_lon numeric(9,6), -- longitude of post location\n    PRIMARY KEY (post_id)\n)\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 (\n    like_id character varying(64) NOT NULL, -- unique identifier for the like\n    user_id character varying(64) NOT NULL, -- identifier of the user who liked (FK to users.user_id)\n    post_id character varying(64), -- identifier of the post being liked (FK to posts.post_id, nullable)\n    comment_id character varying(64), -- identifier of the comment being liked (FK to comments.comment_id, nullable)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of when the like occurred\n    PRIMARY KEY (like_id),\n    CONSTRAINT unique_user_like UNIQUE (user_id, post_id, comment_id), -- prevent duplicate likes\n    CONSTRAINT check_like_target CHECK (post_id IS NOT NULL OR comment_id IS NOT NULL) -- ensure it likes something\n)\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 (\n    hashtag_id character varying(64) NOT NULL, -- unique identifier for the hashtag\n    tag_name character varying(100) NOT NULL UNIQUE, -- the actual hashtag text (without '#')\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when the hashtag was first used\n    PRIMARY KEY (hashtag_id)\n)\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 (\n    conversation_id character varying(64) NOT NULL, -- unique identifier for the conversation\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when conversation was initiated\n    last_message_at timestamp, -- timestamp of the last message in the conversation\n    is_group_chat boolean NOT NULL DEFAULT false, -- indicates if it's a group chat or direct message\n    group_name character varying(100), -- name of the group chat (if applicable)\n    PRIMARY KEY (conversation_id)\n)\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)\n"}
{"conversations": [{"role": "user", "content": "Show me all tokens with their contract addresses and total supply, but only include tokens where the decimals are greater than 6, sorted by total supply in descending order."}, {"role": "assistant", "content": "SELECT token_name, contract_address, total_supply FROM web3.tokens WHERE decimals > 6 ORDER BY total_supply 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 web3.tokens ( token_id.text, contract_address.text, token_name.text, token_symbol.text, decimals.integer, total_supply.numeric )\n"}
{"conversations": [{"role": "user", "content": "List all SUI coins that have the status 'inactive', including their owner address and coin_type."}, {"role": "assistant", "content": "SELECT coin_type, owner FROM sui_coins WHERE status = 'inactive';"}, {"role": "user", "content": "Add the name and symbol for each coin by joining with sui_coins_metadata."}, {"role": "assistant", "content": "SELECT sc.coin_type, sc.owner, scm.name, scm.symbol FROM sui_coins sc JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type WHERE sc.status = 'inactive';"}], "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 varchar, transaction_index bigint, from_address varchar, contract_address varchar, symbol varchar, total_supply varchar, name varchar, decimals bigint, is_erc20 integer, is_erc721 integer, is_erc1155 integer, is_proxy integer, extra_info varchar, pk integer )\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, contract_address.text, wallet_address.text, amount.text, pk.text )\nCREATE TABLE erc20_balances_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\n    amount varchar NOT NULL, -- Wallet's on-chain balance at the corresponding block height\n    pk integer NOT NULL  -- Partition key for the table(floor(block_number / 7200))\n)\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 ( object_id text, status text, coin_type text, balance text, owner text )\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_collections (\n    blockchain varchar NOT NULL, -- blockchain fields for the functionType  in contract\n    contract_address varchar NOT NULL, -- Contract address(with bloom filter)\n    name varchar NOT NULL, -- name fields for the functionType  in contract\n    symbol varchar NOT NULL, -- symbol fields for the functionType  in contract\n    deploy_block_number bigint NOT NULL, -- deploy_block_number fields for the functionType  in contract\n    deploy_block_time bigint NOT NULL, -- deploy_block_time fields for the functionType  in contract\n    erc_type varchar NOT NULL, -- The type of token\n    owner varchar NOT NULL, -- owner fields for the functionType  in contract\n    traits varchar NOT NULL, -- traits fields for the functionType  in contract\n    description varchar NOT NULL, -- description fields for the functionType  in contract\n    slug varchar NOT NULL, -- slug fields for the functionType  in contract\n    media_info varchar NOT NULL, -- media_info fields for the functionType  in contract\n    image_url varchar NOT NULL, -- image_url fields for the functionType  in contract\n    banner_image_url varchar NOT NULL, -- banner_image_url fields for the functionType  in contract\n    updated_at bigint NOT NULL, -- updated_at fields for the functionType  in contract\n    banner varchar NOT NULL, -- banner fields for the functionType  in contract\n    token_count bigint NOT NULL, -- token_count fields for the functionType  in contract\n    floor_price varchar NOT NULL, -- floor_price fields for the functionType  in contract\n    floor_price_symbol varchar NOT NULL, -- floor_price_symbol fields for the functionType  in contract\n    floor_price_contract varchar NOT NULL, -- floor_price_contract fields for the functionType  in contract\n    pk integer NOT NULL  -- Partition key for the table(floor(deploy_block_time / 1000 / 86400 / 30))\n)\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_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 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_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 )\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": "Show the total number of customers in each state."}, {"role": "assistant", "content": "SELECT\n  state,\n  COUNT(customer_id)\nFROM insurance.customers\nGROUP BY\n  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.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.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.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 total fuel cost for each trip along with the trip's route number and the type of the route."}, {"role": "assistant", "content": "SELECT t.trip_id, r.route_number, r.type, SUM(f.total_cost) AS total_fuel_cost\nFROM transportation.trips t\nJOIN transportation.routes r ON t.route_id = r.route_id\nJOIN transportation.fuel_logs f ON t.trip_id = f.trip_id\nGROUP BY t.trip_id, r.route_number, r.type;"}, {"role": "user", "content": "Modify the query to only include trips on routes of type 'Express', and show results ordered by total fuel cost descending."}, {"role": "assistant", "content": "SELECT t.trip_id, r.route_number, r.type, SUM(f.total_cost) AS total_fuel_cost\nFROM transportation.trips t\nJOIN transportation.routes r ON t.route_id = r.route_id\nJOIN transportation.fuel_logs f ON t.trip_id = f.trip_id\nWHERE r.type = 'Express'\nGROUP BY t.trip_id, r.route_number, r.type\nORDER BY total_fuel_cost 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.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.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": "Show me each loyalty program ID along with the full names of all passengers enrolled in that program."}, {"role": "assistant", "content": "SELECT loyalty_program_id, first_name, last_name FROM transportation.passengers WHERE loyalty_program_id IS NOT NULL ORDER BY loyalty_program_id, last_name, first_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 transportation.passengers (\n    passenger_id character varying(64) NOT NULL,  -- unique identifier for the passenger\n    first_name character varying(128) NOT NULL, -- passenger's first name\n    last_name character varying(128) NOT NULL, -- passenger's last name\n    email character varying(128) UNIQUE, -- email address\n    phone_number character varying(32) UNIQUE, -- phone number\n    date_of_birth date, -- passenger's date of birth\n    loyalty_program_id character varying(64), -- identifier for loyalty program membership\n    created_at timestamp with time zone NOT NULL, -- time when the passenger record was created\n    PRIMARY KEY (passenger_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List the first name, last name, and firm name for all lawyers who are partners."}, {"role": "assistant", "content": "SELECT T1.first_name ,  T1.last_name ,  T2.firm_name FROM legal_services.lawyers AS T1 JOIN law_firms AS T2 ON T1.firm_id  =  T2.firm_id WHERE T1.is_partner  =  TRUE"}, {"role": "user", "content": "Only show partners from law firms founded before 2010."}, {"role": "assistant", "content": "SELECT T1.first_name ,  T1.last_name ,  T2.firm_name FROM legal_services.lawyers AS T1 JOIN law_firms AS T2 ON T1.firm_id  =  T2.firm_id WHERE T1.is_partner  =  TRUE AND T2.founded_date < '2010-01-01'"}, {"role": "user", "content": "Sort the results by firm name and then by the lawyer's last name."}, {"role": "assistant", "content": "SELECT T1.first_name ,  T1.last_name ,  T2.firm_name FROM legal_services.lawyers AS T1 JOIN law_firms AS T2 ON T1.firm_id  =  T2.firm_id WHERE T1.is_partner  =  TRUE AND T2.founded_date < '2010-01-01' ORDER BY T2.firm_name ,  T1.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 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": "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": "List all room types with their type name, base rate, and the name of the property they belong to."}, {"role": "assistant", "content": "SELECT rt.room_type_id, rt.type_name, rt.base_rate, p.property_name\nFROM hospitality_technology.room_types rt\nJOIN hospitality_technology.properties p ON rt.property_id = p.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.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)\n"}
{"conversations": [{"role": "user", "content": "Show me the top 5 buyers by total trade volume (quantity * price) in the last 30 days, along with their trade count."}, {"role": "assistant", "content": "SELECT buyer_id, COUNT(trade_id) AS trade_count, SUM(quantity * price) AS total_volume FROM trading_platform.trades WHERE traded_at >= NOW() - INTERVAL '30 days' GROUP BY buyer_id ORDER BY total_volume DESC LIMIT 5"}, {"role": "user", "content": "Now modify the query to also include the average trade price for each buyer."}, {"role": "assistant", "content": "SELECT buyer_id, COUNT(trade_id) AS trade_count, SUM(quantity * price) AS total_volume, AVG(price) AS avg_price FROM trading_platform.trades WHERE traded_at >= NOW() - INTERVAL '30 days' GROUP BY buyer_id ORDER BY total_volume DESC LIMIT 5"}, {"role": "user", "content": "Actually, I want to see the results for sellers instead of buyers, and include the distinct asset count they traded."}, {"role": "assistant", "content": "SELECT seller_id, COUNT(trade_id) AS trade_count, COUNT(DISTINCT asset_id) AS distinct_assets, SUM(quantity * price) AS total_volume, AVG(price) AS avg_price FROM trading_platform.trades WHERE traded_at >= NOW() - INTERVAL '30 days' GROUP BY seller_id ORDER BY total_volume 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 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) )\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": "Find all primary insurance plans that became effective in the last 30 days, showing the patient IDs, policy numbers, and subscriber names, ordered by effective date."}, {"role": "assistant", "content": "SELECT patient_id, policy_number, subscriber_name, effective_date FROM healthcare.patient_insurance WHERE is_primary = true AND effective_date >= (CURRENT_DATE - INTERVAL '30 days') ORDER BY effective_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.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": "Show me all insurance plans that have more than 5 patients enrolled, along with the provider name and count of patients, sorted by patient count in descending order."}, {"role": "assistant", "content": "SELECT i.plan_name, i.insurance_provider, COUNT(p.patient_id) AS patient_count FROM healthcare.insurance_plans i JOIN healthcare.patients p ON i.plan_id = p.primary_insurance_id GROUP BY i.plan_id HAVING COUNT(p.patient_id) > 5 ORDER BY patient_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 ( 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.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": "For each route that originates from a location of type 'Port', list the route number, the name of the origin location, and the total distance accumulated from all completed trips on this route."}, {"role": "assistant", "content": "SELECT\n  r.route_number,\n  l_origin.name AS origin_location_name,\n  SUM(t.distance_km) AS total_accumulated_distance\nFROM transportation.routes AS r\nJOIN transportation.locations AS l_origin\n  ON r.origin_location_id = l_origin.location_id\nJOIN transportation.trips AS t\n  ON r.route_id = t.route_id\nWHERE\n  l_origin.type = 'Port' AND t.status = 'Completed'\nGROUP BY\n  r.route_id,\n  r.route_number,\n  l_origin.name;"}, {"role": "user", "content": "Now, only include routes where the accumulated distance is greater than 5000 kilometers and order the results by accumulated distance descending."}, {"role": "assistant", "content": "SELECT\n  r.route_number,\n  l_origin.name AS origin_location_name,\n  SUM(t.distance_km) AS total_accumulated_distance\nFROM transportation.routes AS r\nJOIN transportation.locations AS l_origin\n  ON r.origin_location_id = l_origin.location_id\nJOIN transportation.trips AS t\n  ON r.route_id = t.route_id\nWHERE\n  l_origin.type = 'Port' AND t.status = 'Completed'\nGROUP BY\n  r.route_id,\n  r.route_number,\n  l_origin.name\nHAVING\n  SUM(t.distance_km) > 5000\nORDER BY\n  total_accumulated_distance DESC;"}, {"role": "user", "content": "Also include the number of completed trips for each of these routes and filter further to only show routes that have had more than 5 completed trips."}, {"role": "assistant", "content": "SELECT\n  r.route_number,\n  l_origin.name AS origin_location_name,\n  SUM(t.distance_km) AS total_accumulated_distance,\n  COUNT(t.trip_id) AS completed_trip_count\nFROM transportation.routes AS r\nJOIN transportation.locations AS l_origin\n  ON r.origin_location_id = l_origin.location_id\nJOIN transportation.trips AS t\n  ON r.route_id = t.route_id\nWHERE\n  l_origin.type = 'Port' AND t.status = 'Completed'\nGROUP BY\n  r.route_id,\n  r.route_number,\n  l_origin.name\nHAVING\n  SUM(t.distance_km) > 5000 AND COUNT(t.trip_id) > 5\nORDER BY\n  total_accumulated_distance 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.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.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": "Could you show me the total payment amount for each guest, including their first and last names?"}, {"role": "assistant", "content": "SELECT g.guest_id,\n       g.first_name,\n       g.last_name,\n       SUM(p.amount) AS total_paid\nFROM hospitality_technology.guests g\nJOIN hospitality_technology.payments p\n  ON g.guest_id = p.guest_id\nGROUP BY g.guest_id,\n         g.first_name,\n         g.last_name\nORDER BY total_paid DESC;"}, {"role": "user", "content": "Actually, only include guests whose total payments exceed 1000 and sort by total_paid ascending."}, {"role": "assistant", "content": "SELECT g.guest_id,\n       g.first_name,\n       g.last_name,\n       SUM(p.amount) AS total_paid\nFROM hospitality_technology.guests g\nJOIN hospitality_technology.payments p\n  ON g.guest_id = p.guest_id\nGROUP BY g.guest_id,\n         g.first_name,\n         g.last_name\nHAVING SUM(p.amount) > 1000\nORDER BY total_paid 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.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.guests ( guest_id.text, first_name.text, last_name.text, email.text, phone_number.text, date_of_birth.date, address_line1.text, city.text, state_province.text, postal_code.text, country_code.text, preferences.text, loyalty_member_id.text, communication_consent.boolean, created_at.timestamp, updated_at.timestamp )\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": "Show me the first and last names of all customers who have filed a claim, along with the claim ID and incident date."}, {"role": "assistant", "content": "SELECT c.first_name, c.last_name, cl.claim_id, cl.incident_date\nFROM insurance.customers c\nJOIN insurance.claims cl ON c.customer_id = cl.customer_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 ( 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.claims ( claim_id text, policy_id text, customer_id text, incident_date timestamp, reported_date timestamp, description text, estimated_loss numeric, status text, settlement_amount numeric, settlement_date date, claim_handler_id text, police_report_number text )\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 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 all trades that occurred on '2023-10-26' and have a status of 'PENDING'."}, {"role": "assistant", "content": "SELECT * FROM financial_services.trades WHERE DATE(trade_timestamp) = '2023-10-26' AND status = 'PENDING';"}, {"role": "user", "content": "From that list, only show the trade_id, security_id, and total_amount."}, {"role": "assistant", "content": "SELECT trade_id, security_id, total_amount FROM financial_services.trades WHERE DATE(trade_timestamp) = '2023-10-26' AND 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 financial_services.trades ( trade_id text, account_id text, security_id text, order_id text, trade_type text, quantity numeric, price_per_unit numeric, total_amount numeric, commission numeric, trade_timestamp timestamp, settlement_date date, status text, execution_venue text )\n"}
{"conversations": [{"role": "user", "content": "I need a report of total maintenance cost per vehicle type."}, {"role": "assistant", "content": "SELECT v.type AS vehicle_type,\n       SUM(m.cost) AS total_maintenance_cost\nFROM transportation.vehicles v\nJOIN transportation.maintenance_logs m ON v.vehicle_id = m.vehicle_id\nGROUP BY v.type;"}, {"role": "user", "content": "Only include types where total maintenance cost is greater than 10000."}, {"role": "assistant", "content": "SELECT v.type AS vehicle_type,\n       SUM(m.cost) AS total_maintenance_cost\nFROM transportation.vehicles v\nJOIN transportation.maintenance_logs m ON v.vehicle_id = m.vehicle_id\nGROUP BY v.type\nHAVING SUM(m.cost) > 10000;"}, {"role": "user", "content": "Also include the number of maintenance events per vehicle type."}, {"role": "assistant", "content": "SELECT v.type AS vehicle_type,\n       SUM(m.cost) AS total_maintenance_cost,\n       COUNT(m.log_id) AS maintenance_event_count\nFROM transportation.vehicles v\nJOIN transportation.maintenance_logs m ON v.vehicle_id = m.vehicle_id\nGROUP BY v.type\nHAVING SUM(m.cost) > 10000;"}, {"role": "user", "content": "Sort the results by average cost per event in descending order."}, {"role": "assistant", "content": "SELECT v.type AS vehicle_type,\n       SUM(m.cost) AS total_maintenance_cost,\n       COUNT(m.log_id) AS maintenance_event_count,\n       AVG(m.cost) AS average_cost_per_event\nFROM transportation.vehicles v\nJOIN transportation.maintenance_logs m ON v.vehicle_id = m.vehicle_id\nGROUP BY v.type\nHAVING SUM(m.cost) > 10000\nORDER BY AVG(m.cost) 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.vehicles (\n    vehicle_id character varying(64) NOT NULL,  -- unique identifier for the vehicle\n    license_plate character varying(32) NOT NULL UNIQUE, -- vehicle license plate\n    vin character varying(17) UNIQUE, -- vehicle identification number\n    make character varying(64) NOT NULL, -- manufacturer of the vehicle\n    model character varying(64) NOT NULL, -- model of the vehicle\n    year integer NOT NULL, -- manufacturing year\n    type character varying(32) NOT NULL, -- type of vehicle (e.g., Bus, Train, Truck, Car, Van)\n    capacity integer, -- passenger or cargo capacity\n    fuel_type character varying(32) NOT NULL, -- e.g., Diesel, Gasoline, Electric, Hydrogen\n    status character varying(32) NOT NULL, -- e.g., Active, Maintenance, Decommissioned\n    depot_id character varying(64), -- identifier of the home depot/base\n    acquisition_date date, -- date the vehicle was acquired\n    PRIMARY KEY (vehicle_id)\n)\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 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 (\n    trip_id character varying(64) NOT NULL,  -- unique identifier for a specific trip instance\n    route_id character varying(64), -- identifier of the route being followed (can be null for ad-hoc trips)\n    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle used\n    driver_id character varying(64) NOT NULL, -- identifier of the driver operating\n    scheduled_departure timestamp with time zone NOT NULL, -- planned departure time\n    actual_departure timestamp with time zone, -- actual departure time\n    scheduled_arrival timestamp with time zone NOT NULL, -- planned arrival time\n    actual_arrival timestamp with time zone, -- actual arrival time\n    origin_location_id character varying(64) NOT NULL, -- actual starting location (could differ from route origin)\n    destination_location_id character varying(64) NOT NULL, -- actual ending location (could differ from route destination)\n    status character varying(32) NOT NULL, -- e.g., Scheduled, In Progress, Completed, Delayed, Cancelled\n    passenger_count integer, -- number of passengers (if applicable)\n    cargo_manifest_id character varying(64), -- link to cargo details (if applicable)\n    PRIMARY KEY (trip_id)\n)\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 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.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": "Show smart money addresses with an ROI greater than 3 and a realized ratio greater than 0.7. Display the address, chain, ROI, realized ratio, and most profitable token."}, {"role": "assistant", "content": "SELECT address, chain, roi, realized_ratio, most_profit_token FROM smart_money_profit WHERE roi > 3 AND realized_ratio > 0.7;"}, {"role": "user", "content": "For these tokens (`most_profit_token` from the previous result), what is the total USD value held by CEXes across all chains? Show the token symbol and the total CEX USD value."}, {"role": "assistant", "content": "WITH HighlyPerformingTokens AS (SELECT DISTINCT most_profit_token FROM smart_money_profit WHERE roi > 3 AND realized_ratio > 0.7 AND most_profit_token IS NOT NULL) SELECT c.token_symbol, SUM(c.usd_value) AS total_cex_usd_value FROM cex_token_balance c JOIN HighlyPerformingTokens h ON c.token_symbol = h.most_profit_token WHERE c.usd_value IS NOT NULL GROUP BY c.token_symbol ORDER BY total_cex_usd_value DESC;"}, {"role": "user", "content": "Filter the previous results to only include tokens where the `average_smart_money_roi` is greater than 10 (1000%) and the `average_smart_money_realized_ratio` is greater than 0.8."}, {"role": "assistant", "content": "WITH CexHeldTokens AS (SELECT DISTINCT token_symbol FROM cex_token_balance WHERE token_symbol IS NOT NULL AND token_symbol != ''), TokenPerformance AS (SELECT s.most_profit_token AS token_symbol, AVG(s.roi) AS average_smart_money_roi, AVG(s.realized_ratio) AS average_smart_money_realized_ratio FROM smart_money_profit s JOIN CexHeldTokens c ON s.most_profit_token = c.token_symbol WHERE s.roi IS NOT NULL AND s.realized_ratio IS NOT NULL GROUP BY s.most_profit_token) SELECT token_symbol, average_smart_money_roi, average_smart_money_realized_ratio FROM TokenPerformance WHERE average_smart_money_roi > 10 AND average_smart_money_realized_ratio > 0.8 ORDER BY average_smart_money_roi DESC;"}, {"role": "user", "content": "For these filtered tokens, add the total USD value held by CEXes (`usd_value` from `cex_token_balance`) to the results. Show token symbol, total CEX USD value, average ROI, and average realized ratio."}, {"role": "assistant", "content": "WITH CexHeldTokens AS (SELECT DISTINCT token_symbol FROM cex_token_balance WHERE token_symbol IS NOT NULL AND token_symbol != ''), TokenPerformance AS (SELECT s.most_profit_token AS token_symbol, AVG(s.roi) AS average_smart_money_roi, AVG(s.realized_ratio) AS average_smart_money_realized_ratio FROM smart_money_profit s JOIN CexHeldTokens c ON s.most_profit_token = c.token_symbol WHERE s.roi IS NOT NULL AND s.realized_ratio IS NOT NULL GROUP BY s.most_profit_token), FilteredPerformance AS (SELECT token_symbol, average_smart_money_roi, average_smart_money_realized_ratio FROM TokenPerformance WHERE average_smart_money_roi > 10 AND average_smart_money_realized_ratio > 0.8) SELECT fp.token_symbol, SUM(c.usd_value) AS total_cex_usd_value, fp.average_smart_money_roi, fp.average_smart_money_realized_ratio FROM FilteredPerformance fp JOIN cex_token_balance c ON fp.token_symbol = c.token_symbol WHERE c.usd_value IS NOT NULL GROUP BY fp.token_symbol, fp.average_smart_money_roi, fp.average_smart_money_realized_ratio ORDER BY fp.average_smart_money_roi 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\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_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": "How many likes were given to comments in June 2024?"}, {"role": "assistant", "content": "SELECT COUNT(*) AS comment_likes_count\nFROM social_media.likes\nWHERE comment_id IS NOT NULL \n  AND DATE_TRUNC('month', created_at) = '2024-06-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 ( comment_id character varying(64) NOT NULL, post_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, parent_comment_id character varying(64), content text NOT NULL, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (comment_id) )\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.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 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) )\nCREATE TABLE social_media.notifications ( notification_id character varying(64) NOT NULL, recipient_user_id character varying(64) NOT NULL, sender_user_id character varying(64), notification_type character varying(30) NOT NULL, target_entity_id character varying(64), target_entity_type character varying(20), created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, read_at timestamp, PRIMARY KEY (notification_id) )\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": "I want a summary of each asset showing the total number of trades executed and the average trade price, including asset name and symbol."}, {"role": "assistant", "content": "SELECT a.asset_id,\n       a.name,\n       a.symbol,\n       COUNT(t.trade_id) AS trades_count,\n       AVG(t.price) AS avg_price\nFROM trading_platform.assets a\nLEFT JOIN trading_platform.trades t ON a.asset_id = t.asset_id\nGROUP BY a.asset_id, a.name, a.symbol;"}, {"role": "user", "content": "Actually, exclude trades before '2024-05-01'."}, {"role": "assistant", "content": "SELECT a.asset_id,\n       a.name,\n       a.symbol,\n       COUNT(t.trade_id) AS trades_count,\n       AVG(t.price) AS avg_price\nFROM trading_platform.assets a\nLEFT JOIN trading_platform.trades t ON a.asset_id = t.asset_id\n  AND t.traded_at >= '2024-05-01'\nGROUP BY a.asset_id, a.name, a.symbol;"}], "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.assets ( asset_id text, 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.peers ( peer_id text, ip_address text, port integer, last_seen timestamp )\nCREATE TABLE trading_platform.metadata ( metadata_id text, asset_id text, key text, value text )\nCREATE TABLE trading_platform.kyc_audit ( kyc_audit_id text, user_id text, status text, reviewed_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List the first name, last name, and hire date of all lawyers who are partners."}, {"role": "assistant", "content": "SELECT first_name ,  last_name ,  hire_date FROM legal_services.lawyers WHERE is_partner  =  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.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": "How many hashtags were created in each month of 2023?"}, {"role": "assistant", "content": "SELECT TO_CHAR(created_at, 'YYYY-MM') AS month, COUNT(*) AS hashtag_count\nFROM social_media.hashtags\nWHERE created_at BETWEEN '2023-01-01' AND '2023-12-31'\nGROUP BY month\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 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": "How many unique patient records are there for each gender?"}, {"role": "assistant", "content": "SELECT gender, COUNT(DISTINCT patient_id) AS patient_count FROM healthcare.patients GROUP BY gender;"}], "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 )\n"}
{"conversations": [{"role": "user", "content": "I want to identify pairs of games developed by the same developer but available on different platforms. Include the titles and platforms of both games."}, {"role": "assistant", "content": "SELECT g1.game_id AS game1_id,\n       g1.title AS game1_title,\n       g1.platform AS platform1,\n       g2.game_id AS game2_id,\n       g2.title AS game2_title,\n       g2.platform AS platform2\nFROM gaming_technology.games g1\nJOIN gaming_technology.games g2\n  ON g1.developer_id = g2.developer_id\n  AND g1.game_id < g2.game_id\n  AND g1.platform <> g2.platform;"}, {"role": "user", "content": "Also, filter to pairs where both games were released after 2021."}, {"role": "assistant", "content": "SELECT g1.game_id AS game1_id,\n       g1.title AS game1_title,\n       g1.platform AS platform1,\n       g2.game_id AS game2_id,\n       g2.title AS game2_title,\n       g2.platform AS platform2\nFROM gaming_technology.games g1\nJOIN gaming_technology.games g2\n  ON g1.developer_id = g2.developer_id\n  AND g1.game_id < g2.game_id\n  AND g1.platform <> g2.platform\nWHERE g1.release_date > '2021-12-31'\n  AND g2.release_date > '2021-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 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)\n"}
{"conversations": [{"role": "user", "content": "For each claim, show the corresponding product_type of the insurance product for the related policy."}, {"role": "assistant", "content": "SELECT cl.claim_id, ip.product_type\nFROM insurance.claims cl\nJOIN insurance.policies p ON cl.policy_id = p.policy_id\nJOIN insurance.insurance_products ip ON p.product_id = ip.product_id;"}, {"role": "user", "content": "Sorry, there is no policies table, I got an error. Can you try joining claims to insurance_products another way?"}, {"role": "assistant", "content": "-- Unable to join directly since there is no 'policies' table connecting claims to insurance_products. If policy_id equals product_id, you may try:\nSELECT claim_id, policy_id, product_type\nFROM insurance.claims\nJOIN insurance.insurance_products ON claims.policy_id = insurance_products.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.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.claims ( claim_id.text, policy_id.text, customer_id.text, incident_date.timestamp, reported_date.timestamp, description.text, estimated_loss.numeric, status.text, settlement_amount.numeric, settlement_date.date, claim_handler_id.text, police_report_number.text )\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, 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 is the average price of tokens held by Binance exchange across all chains in the cex_token_balance table?"}, {"role": "assistant", "content": "SELECT AVG(price) AS average_price FROM cex_token_balance WHERE exchange = '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\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) )\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\n"}
{"conversations": [{"role": "user", "content": "List all appointments for doctor 'doctor_A1'."}, {"role": "assistant", "content": "SELECT appointment_id, patient_id, appointment_time, duration_minutes, reason, status, location_id, notes, created_at FROM healthcare.appointments WHERE doctor_id = 'doctor_A1';"}, {"role": "user", "content": "Okay, filter these to only include those scheduled after '2024-01-01'."}, {"role": "assistant", "content": "SELECT appointment_id, patient_id, appointment_time, duration_minutes, reason, status, location_id, notes, created_at FROM healthcare.appointments WHERE doctor_id = 'doctor_A1' AND appointment_time >= '2024-01-01';"}, {"role": "user", "content": "Further narrow down to only include appointments with a duration greater than 45 minutes."}, {"role": "assistant", "content": "SELECT appointment_id, patient_id, appointment_time, duration_minutes, reason, status, location_id, notes, created_at FROM healthcare.appointments WHERE doctor_id = 'doctor_A1' AND appointment_time >= '2024-01-01' AND duration_minutes > 45;"}, {"role": "user", "content": "Finally, count how many such appointments each patient has had with this doctor."}, {"role": "assistant", "content": "SELECT patient_id, COUNT(*) AS appointment_count FROM healthcare.appointments WHERE doctor_id = 'doctor_A1' AND appointment_time >= '2024-01-01' AND duration_minutes > 45 GROUP 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 (\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)\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": "Count the number of logs for each action type."}, {"role": "assistant", "content": "SELECT action,\n       COUNT(*) AS count\nFROM trading_platform.logs\nGROUP BY action;"}], "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.logs ( log_id text PRIMARY KEY, user_id text, action text, details text, logged_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show me all transactions where the description contains the word 'fee'."}, {"role": "assistant", "content": "SELECT * FROM financial_services.transactions WHERE description ILIKE '%fee%';"}, {"role": "user", "content": "Limit the results to transactions that occurred in the previous month."}, {"role": "assistant", "content": "SELECT * FROM financial_services.transactions WHERE description ILIKE '%fee%' AND transaction_date >= date_trunc('month', CURRENT_DATE - INTERVAL '1 month') AND transaction_date < date_trunc('month', CURRENT_DATE);"}, {"role": "user", "content": "Only include transactions with an amount greater than 20."}, {"role": "assistant", "content": "SELECT * FROM financial_services.transactions WHERE description ILIKE '%fee%' AND transaction_date >= date_trunc('month', CURRENT_DATE - INTERVAL '1 month') AND transaction_date < date_trunc('month', CURRENT_DATE) AND amount > 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 financial_services.transactions ( transaction_id text, account_id text, related_account_id text, transaction_type text, amount numeric, currency text, transaction_date timestamp, effective_date date, description text, status text, reference_number text )\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": "Show me all doctors and the insurance plans provided by 'WellLife'. Include the doctor's full name and the plan name."}, {"role": "assistant", "content": "SELECT d.first_name, d.last_name, ip.plan_name\nFROM healthcare.doctors d\nCROSS JOIN healthcare.insurance_plans ip\nWHERE ip.insurance_provider = 'WellLife';"}, {"role": "user", "content": "Can you add each doctor's specialty and the insurance plan type to the result?"}, {"role": "assistant", "content": "SELECT d.first_name, d.last_name, d.specialty, ip.plan_name, ip.plan_type\nFROM healthcare.doctors d\nCROSS JOIN healthcare.insurance_plans ip\nWHERE ip.insurance_provider = 'WellLife';"}, {"role": "user", "content": "Only show plans where the plan type is 'POS' and doctors whose specialty is 'Radiology'."}, {"role": "assistant", "content": "SELECT d.first_name, d.last_name, d.specialty, ip.plan_name, ip.plan_type\nFROM healthcare.doctors d\nCROSS JOIN healthcare.insurance_plans ip\nWHERE ip.insurance_provider = 'WellLife'\n  AND ip.plan_type = 'POS'\n  AND d.specialty = 'Radiology';"}, {"role": "user", "content": "I actually only want to see the doctor's last name and the plan name, sorted alphabetically by last name."}, {"role": "assistant", "content": "SELECT d.last_name, ip.plan_name\nFROM healthcare.doctors d\nCROSS JOIN healthcare.insurance_plans ip\nWHERE ip.insurance_provider = 'WellLife'\n  AND ip.plan_type = 'POS'\n  AND d.specialty = 'Radiology'\nORDER BY d.last_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 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.insurance_plans ( plan_id text, plan_name text, insurance_provider text, plan_type text, contact_phone text, website text )\n"}
{"conversations": [{"role": "user", "content": "List the claim ID, incident date, and the file name of any associated document for claims reported after '2024-01-01'."}, {"role": "assistant", "content": "SELECT T1.claim_id, T1.incident_date, T2.file_name FROM insurance.claims AS T1 JOIN insurance.claim_documents AS T2 ON T1.claim_id = T2.claim_id WHERE T1.reported_date > '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 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 )\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": "What is the average, minimum, and maximum interest_rate for each loan_type among active loans?"}, {"role": "assistant", "content": "SELECT loan_type,\n       AVG(interest_rate) AS avg_interest_rate,\n       MIN(interest_rate) AS min_interest_rate,\n       MAX(interest_rate) AS max_interest_rate\nFROM financial_services.loans\nWHERE status = 'Active'\nGROUP BY loan_type;"}, {"role": "user", "content": "Exclude loan types with fewer than 5 active loans."}, {"role": "assistant", "content": "SELECT loan_type,\n       AVG(interest_rate) AS avg_interest_rate,\n       MIN(interest_rate) AS min_interest_rate,\n       MAX(interest_rate) AS max_interest_rate\nFROM financial_services.loans\nWHERE status = 'Active'\nGROUP BY loan_type\nHAVING COUNT(*) >= 5;"}, {"role": "user", "content": "Sort the result by average_interest_rate descending and only return the top 5 loan types."}, {"role": "assistant", "content": "SELECT loan_type,\n       AVG(interest_rate) AS avg_interest_rate,\n       MIN(interest_rate) AS min_interest_rate,\n       MAX(interest_rate) AS max_interest_rate\nFROM financial_services.loans\nWHERE status = 'Active'\nGROUP BY loan_type\nHAVING COUNT(*) >= 5\nORDER BY avg_interest_rate 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 financial_services.loans (\n    loan_id character varying(64) NOT NULL, -- unique identifier for the loan, could be same as account_id\n    account_id character varying(64) NOT NULL UNIQUE, -- link to the general account record\n    loan_type character varying(50) NOT NULL, -- e.g., Mortgage, Personal, Auto, Student\n    principal_amount numeric(19, 4) NOT NULL, -- original loan amount\n    current_principal_balance numeric(19, 4) NOT NULL, -- remaining principal\n    interest_rate numeric(6, 4) NOT NULL, -- annual interest rate\n    term_months integer NOT NULL, -- loan term in months\n    origination_date date NOT NULL, -- date the loan was disbursed\n    maturity_date date NOT NULL, -- date the loan is due to be fully repaid\n    monthly_payment numeric(12, 4), -- scheduled monthly payment amount\n    collateral_description text, -- description of collateral, if secured loan\n    status character varying(32) NOT NULL, -- e.g., Active, Paid Off, Defaulted\n    PRIMARY KEY (loan_id),\n    FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Find employees who are managers and list the number of employees they directly manage. Show the manager's full name and the count of their direct reports."}, {"role": "assistant", "content": "SELECT m.first_name || ' ' || m.last_name AS manager_full_name, COUNT(e.employee_id) AS number_of_direct_reports FROM government_services.employees AS e JOIN government_services.employees AS m ON e.manager_employee_id = m.employee_id GROUP BY m.employee_id, manager_full_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.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)\n"}
{"conversations": [{"role": "user", "content": "Provide a report of each user with their username and the count of all log entries from the last 30 days."}, {"role": "assistant", "content": "SELECT u.user_id, u.username, COUNT(l.log_id) AS log_count\nFROM trading_platform.users u\nLEFT JOIN trading_platform.logs l\n  ON u.user_id = l.user_id\n  AND l.logged_at >= CURRENT_DATE - INTERVAL '30 days'\nGROUP BY u.user_id, u.username;"}, {"role": "user", "content": "Actually, show only logs where the action includes the word 'trade'."}, {"role": "assistant", "content": "SELECT u.user_id, u.username, COUNT(l.log_id) AS log_count\nFROM trading_platform.users u\nJOIN trading_platform.logs l\n  ON u.user_id = l.user_id\nWHERE l.logged_at >= CURRENT_DATE - INTERVAL '30 days'\n  AND l.action ILIKE '%trade%'\nGROUP BY u.user_id, u.username;"}, {"role": "user", "content": "Also include the earliest log date for each user in that period."}, {"role": "assistant", "content": "SELECT u.user_id,\n       u.username,\n       COUNT(l.log_id) AS log_count,\n       MIN(l.logged_at) AS first_log_date\nFROM trading_platform.users u\nJOIN trading_platform.logs l\n  ON u.user_id = l.user_id\nWHERE l.logged_at >= CURRENT_DATE - INTERVAL '30 days'\n  AND l.action ILIKE '%trade%'\nGROUP BY u.user_id, u.username;"}, {"role": "user", "content": "Finally, sort the results by log_count descending and limit to the top 5 users."}, {"role": "assistant", "content": "SELECT u.user_id,\n       u.username,\n       COUNT(l.log_id) AS log_count,\n       MIN(l.logged_at) AS first_log_date\nFROM trading_platform.users u\nJOIN trading_platform.logs l\n  ON u.user_id = l.user_id\nWHERE l.logged_at >= CURRENT_DATE - INTERVAL '30 days'\n  AND l.action ILIKE '%trade%'\nGROUP BY u.user_id, u.username\nORDER BY log_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 trading_platform.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)\nCREATE TABLE trading_platform.orders (\n    order_id character varying(64) NOT NULL,  -- unique identifier for the order\n    user_id character varying(64) NOT NULL, -- identifier of the user placing the order\n    wallet_id character varying(64) NOT NULL, -- identifier of the wallet used for the order\n    asset_id character varying(64) NOT NULL, -- identifier of the asset being traded\n    order_type character varying(32) NOT NULL, -- type of the order (e.g., buy, sell)\n    quantity numeric(38,14) NOT NULL, -- quantity of the asset in the order\n    price numeric(38,14) NOT NULL, -- price per unit of the asset\n    status character varying(32) NOT NULL, -- status of the order (e.g., open, filled, canceled)\n    created_at timestamp NOT NULL, -- time when the order was created\n    PRIMARY KEY (order_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 (\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.peers (\n    peer_id character varying(64) NOT NULL,  -- unique identifier for the peer\n    ip_address character varying(15) NOT NULL, -- IP address of the peer\n    port integer NOT NULL, -- port number of the peer\n    last_seen timestamp NOT NULL, -- last time the peer was active\n    PRIMARY KEY (peer_id)\n)\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)\n"}
{"conversations": [{"role": "user", "content": "List all developer names and their founded years, ordered from newest to oldest."}, {"role": "assistant", "content": "SELECT name, founded_year FROM gaming_technology.developers ORDER BY founded_year DESC;"}, {"role": "user", "content": "Show only developers founded after 2015."}, {"role": "assistant", "content": "SELECT name, founded_year FROM gaming_technology.developers WHERE founded_year > 2015 ORDER BY founded_year DESC;"}, {"role": "user", "content": "Can you also include the country of each developer?"}, {"role": "assistant", "content": "SELECT name, country, founded_year FROM gaming_technology.developers WHERE founded_year > 2015 ORDER BY founded_year DESC;"}, {"role": "user", "content": "Only show developers from European countries."}, {"role": "assistant", "content": "SELECT name, country, founded_year FROM gaming_technology.developers WHERE founded_year > 2015 AND country IN ('France','Germany','Spain','Italy','United Kingdom','Netherlands','Sweden','Switzerland','Norway','Finland','Denmark','Belgium','Austria','Ireland','Portugal','Greece','Poland','Hungary','Czech Republic','Romania','Bulgaria','Croatia','Slovakia','Slovenia','Estonia','Latvia','Lithuania','Luxembourg','Iceland','Malta','Cyprus') ORDER BY founded_year 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.developers ( developer_id uuid PRIMARY KEY, name text, country text, founded_year int, website text, created_at timestamptz )\n"}
{"conversations": [{"role": "user", "content": "Get the property name, room type name, base rate, and star rating for all room types with a base_rate above 200 in properties located in the USA, sorted by base_rate in descending order."}, {"role": "assistant", "content": "SELECT p.property_name, rt.type_name, rt.base_rate, p.star_rating\nFROM hospitality_technology.room_types rt\nJOIN hospitality_technology.properties p ON rt.property_id = p.property_id\nWHERE rt.base_rate > 200\n  AND p.country_code = 'USA'\nORDER BY rt.base_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 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.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 ( 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.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 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.payments (\n    payment_id character varying(64) NOT NULL,  -- unique identifier for the payment transaction\n    reservation_id character varying(64), -- FK to reservations (if payment is for a stay)\n    guest_id character varying(64) NOT NULL, -- FK to guests (who paid)\n    bill_id character varying(64), -- FK to bills/invoices this payment applies to\n    amount numeric(12,2) NOT NULL, -- amount of the payment\n    currency_code character varying(3) NOT NULL, -- ISO currency code (e.g., USD, EUR)\n    payment_method character varying(50) NOT NULL, -- e.g., CreditCard, Cash, BankTransfer, Points, Voucher\n    card_type character varying(50), -- e.g., Visa, MasterCard, Amex (if CC)\n    card_last_four character varying(4), -- last 4 digits of CC (if CC)\n    transaction_ref character varying(128), -- reference ID from payment gateway or processor\n    payment_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, -- when the payment occurred\n    status character varying(50) NOT NULL, -- e.g., Pending, Succeeded, Failed, Refunded, Disputed\n    staff_id_processed character varying(64), -- FK to staff (who processed the payment)\n    notes text, -- notes about the payment\n    PRIMARY KEY (payment_id),\n    FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id),\n    FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id),\n    FOREIGN KEY (staff_id_processed) REFERENCES hospitality_technology.staff(staff_id)\n)\n"}
{"conversations": [{"role": "user", "content": "For each user, show their user ID and the count of unique wallet addresses they own."}, {"role": "assistant", "content": "SELECT user_id, COUNT(DISTINCT address) FROM wallets GROUP BY 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 trading_platform.wallets ( wallet_id.text, user_id.text, address.text, private_key.text, created_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "List the username and email of users who have disabled push notifications."}, {"role": "assistant", "content": "SELECT u.username, u.email\nFROM social_media.users u\nJOIN social_media.user_settings s ON u.user_id = s.user_id\nWHERE s.push_notifications_enabled = false;"}, {"role": "user", "content": "Also include only those whose profile is private."}, {"role": "assistant", "content": "SELECT u.username, u.email\nFROM social_media.users u\nJOIN social_media.user_settings s ON u.user_id = s.user_id\nWHERE s.push_notifications_enabled = false\n  AND s.private_profile = 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 (\n    user_id character varying(64) NOT NULL,  -- unique identifier for the user\n    username character varying(50) NOT NULL UNIQUE, -- user's unique handle\n    email character varying(128) NOT NULL UNIQUE, -- user's email address\n    password_hash text NOT NULL, -- hashed password\n    full_name character varying(100), -- user's full name\n    profile_picture_url text, -- URL to the profile picture\n    bio text, -- short user biography\n    location character varying(100), -- user's location\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of account creation\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last profile update\n    is_verified boolean NOT NULL DEFAULT false, -- verification status\n    PRIMARY KEY (user_id)\n)\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.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 (\n    setting_id character varying(64) NOT NULL, -- unique identifier for the setting entry\n    user_id character varying(64) NOT NULL UNIQUE, -- user the settings belong to (FK to users.user_id)\n    theme character varying(20) DEFAULT 'light', -- UI theme ('light', 'dark')\n    email_notifications_enabled boolean DEFAULT true, -- enable/disable email notifications\n    push_notifications_enabled boolean DEFAULT true, -- enable/disable push notifications\n    private_profile boolean DEFAULT false, -- is the user profile private\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last setting change\n    PRIMARY KEY (setting_id)\n)\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": "How many documents are there for each document_type? Show document_type and count ordered by the count in descending order."}, {"role": "assistant", "content": "SELECT document_type,\n       COUNT(*) AS count\nFROM legal_services.documents\nGROUP BY document_type\nORDER BY 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 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 )\n"}
{"conversations": [{"role": "user", "content": "Show all service orders with the service_id, guest's full name, and the status of each order."}, {"role": "assistant", "content": "SELECT so.order_id, so.service_id, g.first_name, g.last_name, so.status\nFROM hospitality_technology.service_orders so\nJOIN hospitality_technology.guests g ON so.guest_id = g.guest_id;"}, {"role": "user", "content": "Only display service orders with status 'InProgress' or 'Pending', and sort them by order_timestamp ascending."}, {"role": "assistant", "content": "SELECT so.order_id, so.service_id, g.first_name, g.last_name, so.status\nFROM hospitality_technology.service_orders so\nJOIN hospitality_technology.guests g ON so.guest_id = g.guest_id\nWHERE so.status IN ('InProgress', 'Pending')\nORDER BY so.order_timestamp 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.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, 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.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.payments (\n    payment_id character varying(64) NOT NULL,  -- unique identifier for the payment transaction\n    reservation_id character varying(64), -- FK to reservations (if payment is for a stay)\n    guest_id character varying(64) NOT NULL, -- FK to guests (who paid)\n    bill_id character varying(64), -- FK to bills/invoices this payment applies to\n    amount numeric(12,2) NOT NULL, -- amount of the payment\n    currency_code character varying(3) NOT NULL, -- ISO currency code (e.g., USD, EUR)\n    payment_method character varying(50) NOT NULL, -- e.g., CreditCard, Cash, BankTransfer, Points, Voucher\n    card_type character varying(50), -- e.g., Visa, MasterCard, Amex (if CC)\n    card_last_four character varying(4), -- last 4 digits of CC (if CC)\n    transaction_ref character varying(128), -- reference ID from payment gateway or processor\n    payment_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, -- when the payment occurred\n    status character varying(50) NOT NULL, -- e.g., Pending, Succeeded, Failed, Refunded, Disputed\n    staff_id_processed character varying(64), -- FK to staff (who processed the payment)\n    notes text, -- notes about the payment\n    PRIMARY KEY (payment_id),\n    FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id),\n    FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id),\n    FOREIGN KEY (staff_id_processed) REFERENCES hospitality_technology.staff(staff_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me all servers that are currently full, meaning current players equals max players. List the server name, region, and max players."}, {"role": "assistant", "content": "SELECT server_name, region, max_players FROM gaming_technology.servers WHERE current_players = max_players;"}, {"role": "user", "content": "Now, only show the full servers from regions that have at least 5 full servers in total."}, {"role": "assistant", "content": "SELECT server_name, region, max_players FROM gaming_technology.servers WHERE current_players = max_players AND region IN ( SELECT region FROM gaming_technology.servers WHERE current_players = max_players GROUP BY region HAVING COUNT(server_id) >= 5 );"}, {"role": "user", "content": "For those specific full servers in those regions, also include the average max players of ALL servers in that region."}, {"role": "assistant", "content": "SELECT server_name, region, max_players, AVG(max_players) OVER (PARTITION BY region) AS regional_avg_max_players FROM gaming_technology.servers WHERE current_players = max_players AND region IN ( SELECT region FROM gaming_technology.servers WHERE current_players = max_players GROUP BY region HAVING COUNT(server_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 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 )\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": "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": "Count the number of posts that have a media URL but no textual content."}, {"role": "assistant", "content": "SELECT COUNT(*) FROM social_media.posts AS T1 WHERE T1.media_url IS NOT NULL AND (T1.content IS NULL OR T1.content = '');"}], "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 (\n    user_id character varying(64) NOT NULL,  -- unique identifier for the user\n    username character varying(50) NOT NULL UNIQUE, -- user's unique handle\n    email character varying(128) NOT NULL UNIQUE, -- user's email address\n    password_hash text NOT NULL, -- hashed password\n    full_name character varying(100), -- user's full name\n    profile_picture_url text, -- URL to the profile picture\n    bio text, -- short user biography\n    location character varying(100), -- user's location\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of account creation\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last profile update\n    is_verified boolean NOT NULL DEFAULT false, -- verification status\n    PRIMARY KEY (user_id)\n)\nCREATE TABLE social_media.posts (\n    post_id character varying(64) NOT NULL, -- unique identifier for the post\n    user_id character varying(64) NOT NULL, -- identifier of the user who created the post (FK to users.user_id)\n    content text, -- textual content of the post\n    media_url text, -- URL to attached media (image/video)\n    media_type character varying(20), -- type of media ('image', 'video', null)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of post creation\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last post edit\n    visibility character varying(20) NOT NULL DEFAULT 'public', -- visibility ('public', 'friends', 'private')\n    location_lat numeric(9,6), -- latitude of post location\n    location_lon numeric(9,6), -- longitude of post location\n    PRIMARY KEY (post_id)\n)\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 (\n    like_id character varying(64) NOT NULL, -- unique identifier for the like\n    user_id character varying(64) NOT NULL, -- identifier of the user who liked (FK to users.user_id)\n    post_id character varying(64), -- identifier of the post being liked (FK to posts.post_id, nullable)\n    comment_id character varying(64), -- identifier of the comment being liked (FK to comments.comment_id, nullable)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of when the like occurred\n    PRIMARY KEY (like_id),\n    CONSTRAINT unique_user_like UNIQUE (user_id, post_id, comment_id), -- prevent duplicate likes\n    CONSTRAINT check_like_target CHECK (post_id IS NOT NULL OR comment_id IS NOT NULL) -- ensure it likes something\n)\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 (\n    hashtag_id character varying(64) NOT NULL, -- unique identifier for the hashtag\n    tag_name character varying(100) NOT NULL UNIQUE, -- the actual hashtag text (without '#')\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when the hashtag was first used\n    PRIMARY KEY (hashtag_id)\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 (\n    conversation_id character varying(64) NOT NULL, -- unique identifier for the conversation\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp when conversation was initiated\n    last_message_at timestamp, -- timestamp of the last message in the conversation\n    is_group_chat boolean NOT NULL DEFAULT false, -- indicates if it's a group chat or direct message\n    group_name character varying(100), -- name of the group chat (if applicable)\n    PRIMARY KEY (conversation_id)\n)\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 (\n    setting_id character varying(64) NOT NULL, -- unique identifier for the setting entry\n    user_id character varying(64) NOT NULL UNIQUE, -- user the settings belong to (FK to users.user_id)\n    theme character varying(20) DEFAULT 'light', -- UI theme ('light', 'dark')\n    email_notifications_enabled boolean DEFAULT true, -- enable/disable email notifications\n    push_notifications_enabled boolean DEFAULT true, -- enable/disable push notifications\n    private_profile boolean DEFAULT false, -- is the user profile private\n    updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last setting change\n    PRIMARY KEY (setting_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all Avalanche tokens from `token_info_avalanche`. Show their tick, creator, and the count of distinct wallet addresses (sender or receiver) that have interacted with this tick in the `token_activities_avalanche` table."}, {"role": "assistant", "content": "SELECT ti.tick, ti.creator, COUNT(DISTINCT wallet_address) AS distinct_wallets_in_activity FROM token_info_avalanche AS ti LEFT JOIN ( SELECT tick, from_address AS wallet_address FROM token_activities_avalanche UNION ALL SELECT tick, to_address AS wallet_address FROM token_activities_avalanche ) AS ta ON ti.tick = ta.tick GROUP BY ti.tick, ti.creator;"}, {"role": "user", "content": "From that list, only show tokens where the count of distinct wallets is greater than 10. Order the results by the distinct wallet count in descending order."}, {"role": "assistant", "content": "SELECT ti.tick, ti.creator, COUNT(DISTINCT wallet_address) AS distinct_wallets_in_activity FROM token_info_avalanche AS ti LEFT JOIN ( SELECT tick, from_address AS wallet_address FROM token_activities_avalanche UNION ALL SELECT tick, to_address AS wallet_address FROM token_activities_avalanche ) AS ta ON ti.tick = ta.tick GROUP BY ti.tick, ti.creator HAVING COUNT(DISTINCT wallet_address) > 10 ORDER BY distinct_wallets_in_activity DESC;"}, {"role": "user", "content": "Limit the previous result to the top 5 tokens with the highest distinct wallet count in activities."}, {"role": "assistant", "content": "SELECT ti.tick, ti.creator, COUNT(DISTINCT wallet_address) AS distinct_wallets_in_activity FROM token_info_avalanche AS ti LEFT JOIN ( SELECT tick, from_address AS wallet_address FROM token_activities_avalanche UNION ALL SELECT tick, to_address AS wallet_address FROM token_activities_avalanche ) AS ta ON ti.tick = ta.tick GROUP BY ti.tick, ti.creator HAVING COUNT(DISTINCT wallet_address) > 10 ORDER BY distinct_wallets_in_activity 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 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 token_balances ( block_number.bigint, block_timestamp.timestamp, tick.text, wallet_address.text, total_supply.decimal, amount.decimal )\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_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 loyalty_program_id, how many unique passengers are enrolled and what is the average fare they have paid?"}, {"role": "assistant", "content": "SELECT\n  p.loyalty_program_id,\n  COUNT(DISTINCT p.passenger_id) AS passenger_count,\n  AVG(b.fare) AS avg_fare\nFROM transportation.passengers p\nJOIN transportation.bookings b\n  ON p.passenger_id = b.passenger_id\nGROUP BY p.loyalty_program_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.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.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.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 )\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 the full names and dates of birth for all patients who do not have a phone number on record."}, {"role": "assistant", "content": "SELECT first_name, last_name, date_of_birth FROM healthcare.patients WHERE phone_number IS NULL OR TRIM(phone_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 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.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.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.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": "Retrieve all beneficiaries with their policy numbers, including beneficiary first and last name, relationship, and the policy end date."}, {"role": "assistant", "content": "SELECT pb.beneficiary_id, pb.first_name, pb.last_name, pb.relationship, p.policy_number, p.end_date\nFROM insurance.policy_beneficiaries pb\nJOIN insurance.policies p ON pb.policy_id = p.policy_id;"}, {"role": "user", "content": "Actually, I only need beneficiaries whose percentage share is greater than 20% and sorted by percentage share in descending order."}, {"role": "assistant", "content": "SELECT pb.beneficiary_id, pb.first_name, pb.last_name, pb.relationship, p.policy_number, p.end_date, pb.percentage_share\nFROM insurance.policy_beneficiaries pb\nJOIN insurance.policies p ON pb.policy_id = p.policy_id\nWHERE pb.percentage_share > 20\nORDER BY pb.percentage_share DESC;"}, {"role": "user", "content": "Also include the policy status and only show records where the policy is still active."}, {"role": "assistant", "content": "SELECT pb.beneficiary_id, pb.first_name, pb.last_name, pb.relationship, p.policy_number, p.end_date, p.status AS policy_status, pb.percentage_share\nFROM insurance.policy_beneficiaries pb\nJOIN insurance.policies p ON pb.policy_id = p.policy_id\nWHERE pb.percentage_share > 20\n  AND p.status = 'Active'\nORDER BY pb.percentage_share DESC;"}, {"role": "user", "content": "Limit the results to the top 5 beneficiaries."}, {"role": "assistant", "content": "SELECT pb.beneficiary_id, pb.first_name, pb.last_name, pb.relationship, p.policy_number, p.end_date, p.status AS policy_status, pb.percentage_share\nFROM insurance.policy_beneficiaries pb\nJOIN insurance.policies p ON pb.policy_id = p.policy_id\nWHERE pb.percentage_share > 20\n  AND p.status = 'Active'\nORDER BY pb.percentage_share 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 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 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.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 )\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 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": "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 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": "Show me all wallet addresses and their private keys for users who have more than 3 wallets."}, {"role": "assistant", "content": "SELECT w.address_id, w.private_key FROM blockchain.wallets w WHERE w.user_id IN (SELECT user_id FROM blockchain.wallets GROUP BY user_id HAVING COUNT(*) > 3);"}, {"role": "user", "content": "Now, filter these results to only show wallets where the private_key starts with '0x1'."}, {"role": "assistant", "content": "SELECT w.address_id, w.private_key FROM blockchain.wallets w WHERE w.user_id IN (SELECT user_id FROM blockchain.wallets GROUP BY user_id HAVING COUNT(*) > 3) AND w.private_key LIKE '0x1%';"}], "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 (\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_id character varying(128) NOT NULL, -- identifier of the address associated with the wallet\n    private_key text NOT NULL, -- private key of the wallet\n    PRIMARY KEY (wallet_id)\n)\n"}
{"conversations": [{"role": "user", "content": "For each user, find the previous user by registration time. List current user_id and username, previous user_id and username, and the time difference in minutes between their registrations."}, {"role": "assistant", "content": "SELECT u.user_id AS current_user_id,\n       u.username AS current_username,\n       p.user_id AS previous_user_id,\n       p.username AS previous_username,\n       EXTRACT(EPOCH FROM (u.created_at - p.created_at)) / 60 AS diff_minutes\nFROM web3.users u\nJOIN web3.users p\n  ON p.created_at = (\n    SELECT MAX(created_at)\n    FROM web3.users\n    WHERE created_at < u.created_at\n  )\nORDER BY u.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 web3.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) )\n"}
{"conversations": [{"role": "user", "content": "Could you provide the total number of game sessions and the number of distinct players for each game genre? Display the genre, session count, and player count."}, {"role": "assistant", "content": "SELECT g.genre, COUNT(gs.session_id) AS session_count, COUNT(DISTINCT gs.player_id) AS player_count FROM gaming_technology.game_sessions AS gs JOIN gaming_technology.games AS g ON gs.game_id = g.game_id WHERE g.genre IS NOT NULL GROUP BY g.genre ORDER BY g.genre;"}, {"role": "user", "content": "Thanks. Can you modify the query to only include games that were released after the year 2020?"}, {"role": "assistant", "content": "SELECT g.genre, COUNT(gs.session_id) AS session_count, COUNT(DISTINCT gs.player_id) AS player_count FROM gaming_technology.game_sessions AS gs JOIN gaming_technology.games AS g ON gs.game_id = g.game_id WHERE g.genre IS NOT NULL AND g.release_date >= '2021-01-01' GROUP BY g.genre ORDER BY g.genre;"}], "system": "You are an 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)\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": "Show me the total number of token transfers for each token symbol on the network."}, {"role": "assistant", "content": "SELECT tk.token_symbol, COUNT(tt.transfer_id) AS total_transfers FROM web3.tokens tk JOIN web3.token_transfers tt ON tk.token_id = tt.token_id GROUP BY tk.token_symbol;"}, {"role": "user", "content": "Actually, I only want to see tokens with more than 100 transfers."}, {"role": "assistant", "content": "SELECT tk.token_symbol, COUNT(tt.transfer_id) AS total_transfers FROM web3.tokens tk JOIN web3.token_transfers tt ON tk.token_id = tt.token_id GROUP BY tk.token_symbol HAVING COUNT(tt.transfer_id) > 100;"}, {"role": "user", "content": "There's a syntax error in your SQL, you're missing a closing parenthesis."}, {"role": "assistant", "content": "SELECT tk.token_symbol, COUNT(tt.transfer_id) AS total_transfers FROM web3.tokens tk JOIN web3.token_transfers tt ON tk.token_id = tt.token_id GROUP BY tk.token_symbol HAVING COUNT(tt.transfer_id) > 100;"}, {"role": "user", "content": "Now sort the results by total_transfers in descending order."}, {"role": "assistant", "content": "SELECT tk.token_symbol, COUNT(tt.transfer_id) AS total_transfers FROM web3.tokens tk JOIN web3.token_transfers tt ON tk.token_id = tt.token_id GROUP BY tk.token_symbol HAVING COUNT(tt.transfer_id) > 100 ORDER BY total_transfers 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 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) )\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 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.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.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) )\n"}
{"conversations": [{"role": "user", "content": "What is the current location of train number Acela 2151?"}, {"role": "assistant", "content": "I'm sorry, but I don't have access to real-time location data for trains. The database only contains static information such as train ID, model, capacity, and maintenance schedules. For current location updates, please check with the train operator or a tracking service."}], "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 (\n    train_id character varying(64) NOT NULL, -- Unique identifier for the train set\n    train_number character varying(32) NOT NULL, -- Operational number of the train (e.g., 'Acela 2151')\n    model character varying(128), -- Model of the train (e.g., 'Siemens Velaro')\n    manufacturer character varying(128), -- Manufacturer of the train\n    year_manufactured integer, -- Year the train was built\n    capacity integer NOT NULL, -- Total passenger capacity\n    status character varying(32) NOT NULL DEFAULT 'Active', -- e.g., Active, Maintenance, Retired\n    last_maintenance_date date, -- Date of last scheduled maintenance\n    next_maintenance_date date, -- Date of next scheduled maintenance\n    PRIMARY KEY (train_id),\n    UNIQUE (train_number)\n)\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": "Find all players who unlocked between 5 and 10 achievements in the year 2023. List their player ID and the count of achievements unlocked in 2023."}, {"role": "assistant", "content": "SELECT player_id, COUNT(*) AS achievement_count_2023 FROM gaming_technology.player_achievements WHERE unlocked_at >= '2023-01-01' AND unlocked_at < '2024-01-01' GROUP BY player_id HAVING COUNT(*) BETWEEN 5 AND 10;"}, {"role": "user", "content": "For the players identified in the previous query, also show the date of their very first achievement unlock (any achievement). Order the results by the first unlock date ascending."}, {"role": "assistant", "content": "WITH PlayersWithSpecific2023Unlocks AS ( SELECT player_id, COUNT(*) AS achievement_count_2023 FROM gaming_technology.player_achievements WHERE unlocked_at >= '2023-01-01' AND unlocked_at < '2024-01-01' GROUP BY player_id HAVING COUNT(*) BETWEEN 5 AND 10 ) SELECT p.player_id, p.achievement_count_2023, MIN(pa.unlocked_at) AS first_overall_unlock FROM PlayersWithSpecific2023Unlocks p JOIN gaming_technology.player_achievements pa ON p.player_id = pa.player_id GROUP BY p.player_id, p.achievement_count_2023 ORDER BY first_overall_unlock 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.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)\n"}
{"conversations": [{"role": "user", "content": "I need to find all bookings for a specific schedule with schedule_id 'sched_1122' and include the passenger and ticket details."}, {"role": "assistant", "content": "SMEMBERS schedule:sched_1122:bookings\nHGETALL booking:book_*\nHGETALL passenger:pass_*\nSMEMBERS booking:book_*:tickets\nHGETALL ticket:tkt_*"}, {"role": "user", "content": "Can you filter the tickets to show only those that are not checked in?"}, {"role": "assistant", "content": "SMEMBERS schedule:sched_1122:bookings\nHGETALL booking:book_*\nHGETALL passenger:pass_*\nSMEMBERS booking:book_*:tickets\nHGET ticket:tkt_* is_checked_in\nIF is_checked_in == 0 THEN\nHGETALL ticket:tkt_*\nENDIF"}, {"role": "user", "content": "Can you also include the car details for each ticket?"}, {"role": "assistant", "content": "SMEMBERS schedule:sched_1122:bookings\nHGETALL booking:book_*\nHGETALL passenger:pass_*\nSMEMBERS booking:book_*:tickets\nHGET ticket:tkt_* is_checked_in\nIF is_checked_in == 0 THEN\nHGETALL ticket:tkt_*\nHGET ticket:tkt_* car_id\nHGETALL car:car_*\nENDIF"}], "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// Use Hashes for platform details. Key format: platform:<platform_id>\n// HSET platform:plat_123 platform_id \"plat_123\" station_id \"station_xyz\" platform_number \"1A\" track_number \"T1\" status \"Operational\" length_meters 250.50 accessible 1\n\n// To link platforms to stations (optional):\n// SADD station:station_xyz:platforms platform:plat_123 platform:plat_456\n// Use Hashes for train details. Key format: train:<train_id>\n// HSET train:train_789 train_id \"train_789\" train_number \"Acela 2151\" model \"Siemens Velaro\" ... status \"Active\" ...\n\n// To find train by train_number (optional index):\n// SET train_number:\"Acela 2151\" train:train_789\n// Use Hashes for car details. Key format: car:<car_id>\n// HSET car:car_abc car_id \"car_abc\" train_id \"train_789\" car_number \"C3\" car_type \"Passenger\" class \"Business\" capacity 60 features \"WiFi,Power Outlet\"\n\n// To link cars to trains (optional):\n// SADD train:train_789:cars car:car_abc car:car_def\n// Use Hashes for details. Key format: route_station:<route_station_id>\n// HSET route_station:rs_ne_1 route_station_id \"rs_ne_1\" route_id \"route_ne_corr\" station_id \"station_bos\" sequence_order 1 ...\n\n// To find stops for a route, use a Sorted Set (score by sequence_order):\n// ZADD route:route_ne_corr:stops 1 route_station:rs_ne_1\n// ZADD route:route_ne_corr:stops 2 route_station:rs_ne_2\n// Use Hashes for schedule details. Key format: schedule:<schedule_id>\n// HSET schedule:sched_1122 schedule_id \"sched_1122\" train_id \"train_789\" route_id \"route_ne_corr\" departure_datetime \"2024-05-10T08:00:00-04:00\" ... status \"Scheduled\"\n// Use Hashes for details. Key format: schedule_stop:<stop_id>\n// HSET schedule_stop:stop_sched1122_1 stop_id \"stop_sched1122_1\" schedule_id \"sched_1122\" station_id \"station_bos\" ...\n\n// To find stops for a schedule, use a Sorted Set (score by sequence_order):\n// ZADD schedule:sched_1122:stops 1 schedule_stop:stop_sched1122_1\n// ZADD schedule:sched_1122:stops 2 schedule_stop:stop_sched1122_2\n// Use Hashes for passenger details. Key format: passenger:<passenger_id>\n// HSET passenger:pass_pqr passenger_id \"pass_pqr\" first_name \"Alice\" last_name \"Smith\" email \"alice.smith@example.com\" ...\n\n// To find passenger by email (optional index):\n// SET passenger_email:\"alice.smith@example.com\" passenger:pass_pqr\n// Use Hashes for booking details. Key format: booking:<booking_id>\n// HSET booking:book_zyx booking_id \"book_zyx\" passenger_id \"pass_pqr\" schedule_id \"sched_1122\" ... status \"Confirmed\" ...\n\n// To link bookings to passengers/schedules (optional):\n// SADD passenger:pass_pqr:bookings booking:book_zyx\n// SADD schedule:sched_1122:bookings booking:book_zyx\n// Use Hashes for ticket details. Key format: ticket:<ticket_id>\n// HSET ticket:tkt_1a2b ticket_id \"tkt_1a2b\" booking_id \"book_zyx\" car_id \"car_abc\" seat_number \"12A\" ... is_checked_in 0 ...\n\n// To link tickets to bookings (optional):\n// SADD booking:book_zyx:tickets ticket:tkt_1a2b\n// Use Hashes for staff details. Key format: staff:<staff_id>\n// HSET staff:staff_mno staff_id \"staff_mno\" first_name \"Bob\" ... employee_number \"E12345\" ... is_active 1\n\n// To find staff by employee number (optional index):\n// SET staff_employee_number:\"E12345\" staff:staff_mno\n// Use Hashes for maintenance record details. Key format: maintenance_record:<record_id>\n// HSET maintenance_record:maint_rec_001 record_id \"maint_rec_001\" asset_id \"train_789\" asset_type \"Train\" ... status \"Completed\"\n\n// To link records to assets (optional):\n// SADD train:train_789:maintenance maintenance_record:maint_rec_001\n// SADD platform:plat_123:maintenance maintenance_record:maint_rec_002\n"}
{"conversations": [{"role": "user", "content": "List all users who performed more than 10 'view' actions in the logs, along with their action counts."}, {"role": "assistant", "content": "SELECT user_id, COUNT(log_id) AS view_action_count FROM trading_platform.logs WHERE action = 'view' GROUP BY user_id HAVING COUNT(log_id) > 10 ORDER BY view_action_count DESC;"}, {"role": "user", "content": "Now include only users who performed these actions on cryptocurrency assets."}, {"role": "assistant", "content": "SELECT l.user_id, COUNT(l.log_id) AS view_action_count FROM trading_platform.logs l JOIN trading_platform.assets a ON l.details->>'asset_id' = a.asset_id WHERE l.action = 'view' AND a.type = 'cryptocurrency' GROUP BY l.user_id HAVING COUNT(l.log_id) > 10 ORDER BY view_action_count DESC;"}, {"role": "user", "content": "Actually, I want to see the most recent timestamp of their last view action as well."}, {"role": "assistant", "content": "SELECT l.user_id, COUNT(l.log_id) AS view_action_count, MAX(l.logged_at) AS last_view_time FROM trading_platform.logs l JOIN trading_platform.assets a ON l.details->>'asset_id' = a.asset_id WHERE l.action = 'view' AND a.type = 'cryptocurrency' GROUP BY l.user_id HAVING COUNT(l.log_id) > 10 ORDER BY view_action_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.assets ( asset_id text, name text, symbol text, type text )\nCREATE TABLE trading_platform.logs ( log_id text, user_id text, action text, details text, logged_at timestamp )\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": "Show me all trips along with the vehicle make and the route distance in km."}, {"role": "assistant", "content": "SELECT t.trip_id, v.make, r.distance_km\nFROM transportation.trips t\nJOIN transportation.vehicles v ON t.vehicle_id = v.vehicle_id\nJOIN transportation.routes r ON t.route_id = r.route_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 (\n    vehicle_id character varying(64) NOT NULL,  -- unique identifier for the vehicle\n    license_plate character varying(32) NOT NULL UNIQUE, -- vehicle license plate\n    vin character varying(17) UNIQUE, -- vehicle identification number\n    make character varying(64) NOT NULL, -- manufacturer of the vehicle\n    model character varying(64) NOT NULL, -- model of the vehicle\n    year integer NOT NULL, -- manufacturing year\n    type character varying(32) NOT NULL, -- type of vehicle (e.g., Bus, Train, Truck, Car, Van)\n    capacity integer, -- passenger or cargo capacity\n    fuel_type character varying(32) NOT NULL, -- e.g., Diesel, Gasoline, Electric, Hydrogen\n    status character varying(32) NOT NULL, -- e.g., Active, Maintenance, Decommissioned\n    depot_id character varying(64), -- identifier of the home depot/base\n    acquisition_date date, -- date the vehicle was acquired\n    PRIMARY KEY (vehicle_id)\n)\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 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.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": "List all claims that have at least one document of type 'INVOICE', including the claim ID, incident date, estimated loss, and the document's file name."}, {"role": "assistant", "content": "SELECT c.claim_id, c.incident_date, c.estimated_loss, d.file_name\nFROM insurance.claims c\nJOIN insurance.claim_documents d ON c.claim_id = d.claim_id\nWHERE d.document_type = 'INVOICE';"}, {"role": "user", "content": "Also show the file size in bytes and the uploaded date for each document."}, {"role": "assistant", "content": "SELECT c.claim_id, c.incident_date, c.estimated_loss, d.file_name, d.file_size_bytes, d.uploaded_at\nFROM insurance.claims c\nJOIN insurance.claim_documents d ON c.claim_id = d.claim_id\nWHERE d.document_type = 'INVOICE';"}, {"role": "user", "content": "Actually, just show the claims where the document file size is greater than 100,000 bytes."}, {"role": "assistant", "content": "SELECT c.claim_id, c.incident_date, c.estimated_loss, d.file_name, d.file_size_bytes, d.uploaded_at\nFROM insurance.claims c\nJOIN insurance.claim_documents d ON c.claim_id = d.claim_id\nWHERE d.document_type = 'INVOICE'\n  AND d.file_size_bytes > 100000;"}], "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 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.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"}