{"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 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": "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": "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": "For each player, calculate the total quantity of items they have acquired. Return player_id and total_quantity."}, {"role": "assistant", "content": "SELECT player_id,\n       SUM(quantity) AS total_quantity\nFROM gaming_technology.player_inventory\nGROUP BY player_id;"}, {"role": "user", "content": "Exclude players whose total_quantity is less than 50."}, {"role": "assistant", "content": "SELECT player_id,\n       SUM(quantity) AS total_quantity\nFROM gaming_technology.player_inventory\nGROUP BY player_id\nHAVING SUM(quantity) >= 50;"}, {"role": "user", "content": "Also include the number of distinct items each player has acquired as distinct_item_count."}, {"role": "assistant", "content": "SELECT player_id,\n       SUM(quantity) AS total_quantity,\n       COUNT(DISTINCT item_id) AS distinct_item_count\nFROM gaming_technology.player_inventory\nGROUP BY player_id\nHAVING SUM(quantity) >= 50;"}, {"role": "user", "content": "Finally, order the results by total_quantity in descending order."}, {"role": "assistant", "content": "SELECT player_id,\n       SUM(quantity) AS total_quantity,\n       COUNT(DISTINCT item_id) AS distinct_item_count\nFROM gaming_technology.player_inventory\nGROUP BY player_id\nHAVING SUM(quantity) >= 50\nORDER BY total_quantity DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.player_inventory ( inventory_id uuid PRIMARY KEY, player_id uuid, item_id uuid, quantity int, acquired_at timestamptz, instance_data 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 the agency name, location name, address, and contact phone for all accessible service locations in the city of 'Seattle'."}, {"role": "assistant", "content": "SELECT t1.agency_name, t2.location_name, t2.address, t2.contact_phone FROM government_services.agencies AS t1 JOIN government_services.service_locations AS t2 ON t1.agency_id = t2.agency_id WHERE t2.city = 'Seattle' AND t2.is_accessible = TRUE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens (\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 (\n    agency_id character varying(64) NOT NULL, -- unique identifier for the agency\n    agency_name character varying(255) NOT NULL, -- full name of the government agency\n    jurisdiction_level character varying(50) NOT NULL, -- e.g., Federal, State, County, City\n    primary_contact_email character varying(128),\n    main_phone_number character varying(32),\n    website_url character varying(255),\n    established_date date,\n    parent_agency_id character varying(64), -- FK to self for hierarchical structure\n    PRIMARY KEY (agency_id)\n)\nCREATE TABLE government_services.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 (\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 (\n    payment_id character varying(64) NOT NULL, -- unique identifier for the payment\n    application_id character varying(64), -- FK to applications table (nullable if payment not for specific app)\n    citizen_id character varying(64) NOT NULL, -- FK to citizens table\n    service_id character varying(64), -- FK to services table (identifies what was paid for)\n    amount numeric(12, 2) NOT NULL, -- amount paid\n    currency character varying(3) NOT NULL DEFAULT 'USD',\n    payment_method character varying(50), -- e.g., Credit Card, Bank Transfer, Check\n    payment_provider_reference character varying(128), -- transaction ID from payment gateway\n    payment_timestamp timestamp NOT NULL,\n    status character varying(30) NOT NULL, -- e.g., Pending, Succeeded, Failed, Refunded\n    notes text,\n    PRIMARY KEY (payment_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": "Show me the top 5 ERC20 tokens with the highest total supply, along with their names and contract addresses, but only include tokens with decimals equal to 18."}, {"role": "assistant", "content": "SELECT name, contract_address, total_supply FROM token_metas WHERE is_erc20 = 1 AND decimals = 18 ORDER BY CAST(total_supply AS decimal) DESC LIMIT 5;"}, {"role": "user", "content": "Can you join this with the token_prices table to include the current price of each token?"}, {"role": "assistant", "content": "SELECT tm.name, tm.contract_address, tm.total_supply, tp.price FROM token_metas tm JOIN token_prices tp ON tm.contract_address = tp.address WHERE tm.is_erc20 = 1 AND tm.decimals = 18 ORDER BY CAST(tm.total_supply AS decimal) DESC LIMIT 5;"}, {"role": "user", "content": "Now filter these results to only show tokens where the price is greater than $0.1."}, {"role": "assistant", "content": "SELECT tm.name, tm.contract_address, tm.total_supply, tp.price FROM token_metas tm JOIN token_prices tp ON tm.contract_address = tp.address WHERE tm.is_erc20 = 1 AND tm.decimals = 18 AND tp.price > 0.1 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_historical ( block_number bigint, contract_address text, wallet_address text, amount text, pk integer )\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, contract_address.text, wallet_address.text, token_id.text, contract_type.text, amount.text, pk.integer )\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_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 (\n    blockchain varchar NOT NULL, -- blockchain fields for the functionType  in contract\n    contract_address varchar NOT NULL, -- Contract address(with bloom filter)\n    token_id varchar NOT NULL, -- The number of the token\n    contract_name varchar NOT NULL, -- contract_name fields for the functionType  in contract\n    erc_type varchar NOT NULL, -- The type of token\n    amount bigint NOT NULL, -- amount fields for the functionType  in contract\n    minter varchar NOT NULL, -- minter fields for the functionType  in contract\n    owner varchar NOT NULL, -- owner fields for the functionType  in contract\n    mint_block_number bigint NOT NULL, -- mint_block_number fields for the functionType  in contract\n    mint_time bigint NOT NULL, -- mint_time fields for the functionType  in contract\n    mint_transaction_hash varchar NOT NULL, -- mint_transaction_hash fields for the functionType  in contract\n    mint_price varchar NOT NULL, -- mint_price fields for the functionType  in contract\n    token_uri varchar NOT NULL, -- token_uri fields for the functionType  in contract\n    metadata varchar NOT NULL, -- metadata fields for the functionType  in contract\n    name varchar NOT NULL, -- name fields for the functionType  in contract\n    image_uri varchar NOT NULL, -- image_uri fields for the functionType  in contract\n    traits varchar NOT NULL, -- traits fields for the functionType  in contract\n    updated_at bigint NOT NULL, -- updated_at fields for the functionType  in contract\n    status varchar NOT NULL, -- status fields for the functionType  in contract\n    rarity_score real NOT NULL, -- rarity_score fields for the functionType  in contract\n    rarity_rank integer NOT NULL, -- rarity_rank fields for the functionType  in contract\n    unique_attribute_count integer NOT NULL, -- unique_attribute_count fields for the functionType  in contract\n    pk integer NOT NULL  -- Partition key for the table(floor(mint_time / 1000 / 86400 / 30))\n)\nCREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash varchar, log_index integer, contract_address varchar, pk integer )\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 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_info_bitcoin (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    tick varchar(255) NOT NULL, -- Ticker:  Identifier of the inscription\n    max_supply decimal(38,0) NOT NULL, -- Max supply: Set max supply of the inscription\n    lim decimal(38,0) NOT NULL, -- Mint limit: limit per inscription\n    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint\n    dec integer NOT NULL, -- Decimal for minimum divie\n    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)\n)\nCREATE TABLE token_activities_avalanche (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    log_index integer NOT NULL, -- Index of the log within the transaction\n    type varchar(20) NOT NULL, -- Operation: Type of event (deploy, mint, transfer, list)\n    tick varchar(255) NOT NULL, -- Ticker: Identifier of the inscription\n    id varchar(255) NOT NULL, -- Unique identifier of the inscription\n    amt decimal(38,0) NOT NULL, -- Amount to mint: States the amount of the inscription to operation. When operation is mint, has to be less or equal to \"lim\"\n    from_address varchar(42) NOT NULL, -- Address sending the inscription\n    to_address varchar(42) NOT NULL  -- Address receiving the inscription\n)\nCREATE TABLE token_balances_avalanche (\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)\n"}
{"conversations": [{"role": "user", "content": "List all insurance products that have 'auto' in their product type and are currently active, showing their product name and base premium."}, {"role": "assistant", "content": "SELECT product_id, product_name, product_type, base_premium FROM insurance.insurance_products WHERE product_type LIKE '%auto%' AND is_active = true;"}, {"role": "user", "content": "Now order these results by base premium in descending order and include the coverage details."}, {"role": "assistant", "content": "SELECT product_id, product_name, product_type, base_premium, coverage_details FROM insurance.insurance_products WHERE product_type LIKE '%auto%' AND is_active = true ORDER BY base_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.customers ( customer_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, date_of_birth date NOT NULL, ssn_hash character varying(128), address_line1 character varying(255) NOT NULL, address_line2 character varying(255), city character varying(100) NOT NULL, state character varying(50) NOT NULL, zip_code character varying(20) NOT NULL, country character varying(50) NOT NULL DEFAULT 'USA', phone_number character varying(30), email character varying(128) UNIQUE, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at timestamp, status character varying(20) NOT NULL DEFAULT 'Active', PRIMARY KEY (customer_id) )\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 character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, agency_name character varying(150), license_number character varying(100) NOT NULL UNIQUE, license_state character varying(50) NOT NULL, contact_email character varying(128) UNIQUE, contact_phone character varying(30), hire_date date, termination_date date, status character varying(20) NOT NULL DEFAULT 'Active', commission_rate numeric(5, 4) NOT NULL DEFAULT 0.05, manager_id character varying(64), PRIMARY KEY (agent_id) )\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) )\nCREATE TABLE insurance.policy_beneficiaries ( beneficiary_id character varying(64) NOT NULL, policy_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, relationship character varying(50) NOT NULL, percentage_share numeric(5, 2) NOT NULL CHECK (percentage_share > 0 AND percentage_share <= 100), contact_info text, added_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (beneficiary_id), UNIQUE (policy_id, customer_id) )\n"}
{"conversations": [{"role": "user", "content": "Show me the total deposit and withdrawal amounts for each account in February 2024."}, {"role": "assistant", "content": "SELECT account_id, SUM(CASE WHEN transaction_type = 'Deposit' THEN amount ELSE 0 END) AS total_deposit, SUM(CASE WHEN transaction_type = 'Withdrawal' THEN amount ELSE 0 END) AS total_withdrawal FROM financial_services.transactions WHERE transaction_date >= '2024-02-01' AND transaction_date < '2024-03-01' GROUP BY account_id;"}, {"role": "user", "content": "Can you include the account_number and account_type for each account as well?"}, {"role": "assistant", "content": "SELECT a.account_number, a.account_type, t.account_id, SUM(CASE WHEN t.transaction_type = 'Deposit' THEN t.amount ELSE 0 END) AS total_deposit, SUM(CASE WHEN t.transaction_type = 'Withdrawal' THEN t.amount ELSE 0 END) AS total_withdrawal FROM financial_services.transactions t INNER JOIN financial_services.accounts a ON t.account_id = a.account_id WHERE t.transaction_date >= '2024-02-01' AND t.transaction_date < '2024-03-01' GROUP BY a.account_number, a.account_type, t.account_id;"}, {"role": "user", "content": "Actually, only show accounts where the total deposit amount exceeds 10,000."}, {"role": "assistant", "content": "SELECT a.account_number, a.account_type, t.account_id, SUM(CASE WHEN t.transaction_type = 'Deposit' THEN t.amount ELSE 0 END) AS total_deposit, SUM(CASE WHEN t.transaction_type = 'Withdrawal' THEN t.amount ELSE 0 END) AS total_withdrawal FROM financial_services.transactions t INNER JOIN financial_services.accounts a ON t.account_id = a.account_id WHERE t.transaction_date >= '2024-02-01' AND t.transaction_date < '2024-03-01' GROUP BY a.account_number, a.account_type, t.account_id HAVING SUM(CASE WHEN t.transaction_type = 'Deposit' THEN t.amount ELSE 0 END) > 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 financial_services.customers ( customer_id text PRIMARY KEY, first_name text, last_name text, date_of_birth date, ssn_hash text, address text, city text, state text, zip_code text, country text, email text, phone_number text, created_at timestamp, status text, risk_profile text )\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 (\n    transaction_id character varying(64) NOT NULL, -- unique identifier for the transaction\n    account_id character varying(64) NOT NULL, -- account involved in the transaction\n    related_account_id character varying(64), -- counterpart account for transfers\n    transaction_type character varying(50) NOT NULL, -- e.g., Deposit, Withdrawal, Transfer, Payment, Fee, Interest\n    amount numeric(19, 4) NOT NULL, -- transaction amount\n    currency character varying(3) NOT NULL, -- transaction currency\n    transaction_date timestamp NOT NULL, -- exact time of the transaction\n    effective_date date NOT NULL, -- date the transaction affects the balance\n    description text, -- description or memo of the transaction\n    status character varying(32) NOT NULL, -- e.g., Pending, Completed, Failed, Reversed\n    reference_number character varying(128), -- external reference if applicable (e.g., check number)\n    PRIMARY KEY (transaction_id),\n    FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id),\n    FOREIGN KEY (related_account_id) REFERENCES financial_services.accounts(account_id)\n)\nCREATE TABLE financial_services.securities ( security_id text, ticker_symbol text, isin_code text, cusip_code text, security_name text, security_type text, exchange text, currency text, issuer_name text, sector text, last_updated timestamp )\nCREATE TABLE financial_services.trades ( trade_id character varying(64) NOT NULL, account_id character varying(64) NOT NULL, security_id character varying(64) NOT NULL, order_id character varying(64), trade_type character varying(10) NOT NULL, quantity numeric(19, 8) NOT NULL, price_per_unit numeric(19, 8) NOT NULL, total_amount numeric(19, 4) NOT NULL, commission numeric(10, 4), trade_timestamp timestamp NOT NULL, settlement_date date, status character varying(32) NOT NULL, execution_venue character varying(100), PRIMARY KEY (trade_id), FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id), FOREIGN KEY (security_id) REFERENCES financial_services.securities(security_id) )\nCREATE TABLE financial_services.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 (\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": "For each customer, provide a summary of their account statuses, showing their full name, account status, and the count of accounts for each status."}, {"role": "assistant", "content": "SELECT c.first_name, c.last_name, a.status, COUNT(a.account_id) AS account_count FROM financial_services.accounts a JOIN financial_services.customers c ON a.customer_id = c.customer_id GROUP BY c.customer_id, c.first_name, c.last_name, a.status ORDER BY c.last_name, c.first_name, a.status;"}, {"role": "user", "content": "Refine this to only include customers who have accounts in at least two different statuses."}, {"role": "assistant", "content": "SELECT c.first_name, c.last_name, a.status, COUNT(a.account_id) AS account_count FROM financial_services.accounts a JOIN financial_services.customers c ON a.customer_id = c.customer_id GROUP BY c.customer_id, c.first_name, c.last_name, a.status HAVING c.customer_id IN ( SELECT customer_id FROM financial_services.accounts GROUP BY customer_id HAVING COUNT(DISTINCT status) >= 2 ) ORDER BY c.last_name, c.first_name, a.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 financial_services.accounts (\n    account_id character varying(64) NOT NULL, -- unique identifier for the account\n    customer_id character varying(64) NOT NULL, -- foreign key linking to the customer\n    account_number character varying(128) NOT NULL UNIQUE, -- unique account number visible to customer\n    account_type character varying(50) NOT NULL, -- e.g., Checking, Savings, Investment, Loan, Credit Card\n    balance numeric(19, 4) NOT NULL DEFAULT 0.00, -- current account balance\n    currency character varying(3) NOT NULL, -- currency code (e.g., USD, EUR)\n    opened_date date NOT NULL, -- date the account was opened\n    status character varying(32) NOT NULL, -- e.g., Open, Closed, Frozen\n    interest_rate numeric(5, 4), -- annual interest rate, if applicable\n    last_updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last account update\n    PRIMARY KEY (account_id),\n    FOREIGN KEY (customer_id) REFERENCES financial_services.customers(customer_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Retrieve all pairs of distinct contract IDs that were created by the same creator within an hour of each other. Include the creator address and the timestamps of both contracts."}, {"role": "assistant", "content": "SELECT sc1.creator_address, sc1.contract_id AS contract_id_1, sc1.timestamp AS timestamp_1, sc2.contract_id AS contract_id_2, sc2.timestamp AS timestamp_2 FROM blockchain.smart_contracts sc1 JOIN blockchain.smart_contracts sc2 ON sc1.creator_address = sc2.creator_address AND sc1.contract_id <> sc2.contract_id WHERE ABS(UNIX_TIMESTAMP(sc1.timestamp) - UNIX_TIMESTAMP(sc2.timestamp)) <= 3600 AND sc1.timestamp < sc2.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 blockchain.smart_contracts ( contract_id.text, creator_address.text, code.text, timestamp.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": "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 room types that have at least one service in the 'Spa' category, including the room type name, property name, and service name."}, {"role": "assistant", "content": "SELECT DISTINCT rt.type_name, p.property_name, s.service_name\nFROM hospitality_technology.room_types AS rt\nJOIN hospitality_technology.properties AS p ON rt.property_id = p.property_id\nJOIN hospitality_technology.services AS s ON rt.property_id = s.property_id\nWHERE s.category = 'Spa';"}, {"role": "user", "content": "Actually, only show room types with a base_rate above 200."}, {"role": "assistant", "content": "SELECT DISTINCT rt.type_name, p.property_name, s.service_name\nFROM hospitality_technology.room_types AS rt\nJOIN hospitality_technology.properties AS p ON rt.property_id = p.property_id\nJOIN hospitality_technology.services AS s ON rt.property_id = s.property_id\nWHERE s.category = 'Spa'\n  AND rt.base_rate > 200;"}, {"role": "user", "content": "Also sort the results by base_rate descending and limit to 10."}, {"role": "assistant", "content": "SELECT DISTINCT rt.type_name, p.property_name, s.service_name\nFROM hospitality_technology.room_types AS rt\nJOIN hospitality_technology.properties AS p ON rt.property_id = p.property_id\nJOIN hospitality_technology.services AS s ON rt.property_id = s.property_id\nWHERE s.category = 'Spa'\n  AND rt.base_rate > 200\nORDER BY rt.base_rate DESC\nLIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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 ( 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 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.reservations ( reservation_id text PRIMARY KEY, property_id text, guest_id text, room_id text, room_type_id text, check_in_date date, check_out_date date, actual_check_in_ts timestamp, actual_check_out_ts timestamp, num_adults int, num_children int, status text, booking_source text, rate_plan_id text, total_amount numeric, amount_paid numeric, special_requests text, created_at timestamp, updated_at timestamp )\nCREATE TABLE hospitality_technology.staff ( staff_id text PRIMARY KEY, property_id text, first_name text, last_name text, position text, work_email text, work_phone text, hire_date date, termination_date date, is_active boolean, access_level int, manager_id text, created_at timestamp )\nCREATE TABLE hospitality_technology.services ( service_id.text, property_id.text, service_name.text, description.text, category.text, price.numeric, unit.text, is_available.boolean, department.text )\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": "Retrieve the policy_number, start_date, end_date, premium_amount, and corresponding product_name for policies with a coverage_limit greater than 500000."}, {"role": "assistant", "content": "SELECT p.policy_number, p.start_date, p.end_date, p.premium_amount, ip.product_name\nFROM insurance.policies p\nJOIN insurance.insurance_products ip ON p.product_id = ip.product_id\nWHERE p.coverage_limit > 500000;"}], "system": "You are an SQL statement expert. Given the table structure 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, 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": "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": "Show all medical records with the record_id, record_date, the patient's insurance policy_number, and the doctor's ID, for records linked to a currently active insurance policy."}, {"role": "assistant", "content": "SELECT mr.record_id, mr.record_date, pi.policy_number, mr.doctor_id\nFROM healthcare.medical_records mr\nINNER JOIN healthcare.patient_insurance pi ON mr.patient_id = pi.patient_id\nWHERE pi.expiration_date IS NULL OR pi.expiration_date >= CURRENT_DATE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.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.json, created_at.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": "Show the tokens with a negative net flow this month on all chains."}, {"role": "assistant", "content": "SELECT token_symbol, chain, net_flow FROM smart_money_token_performance WHERE net_flow < 0 AND date_trunc('month', CURRENT_DATE) = date_trunc('month', now());"}, {"role": "user", "content": "Order them by net flow ascending and only show the bottom 5."}, {"role": "assistant", "content": "SELECT token_symbol, chain, net_flow FROM smart_money_token_performance WHERE net_flow < 0 AND date_trunc('month', CURRENT_DATE) = date_trunc('month', now()) ORDER BY net_flow ASC 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 smart_money_token_performance ( token_address character varying(100) NOT NULL, token_symbol character varying(100), pnl numeric(38,2), net_flow numeric(38,2), avg_cost numeric(38,16), price double precision, realized_ratio numeric(10,2), roi numeric(10,2), chain character varying(100) )\n"}
{"conversations": [{"role": "user", "content": "List all reservations where the number of adults is greater than 2, showing reservation_id, guest_id, and the total_amount."}, {"role": "assistant", "content": "SELECT reservation_id, guest_id, total_amount\nFROM hospitality_technology.reservations\nWHERE num_adults > 2;"}, {"role": "user", "content": "Can you also include the room_type_id and the status for each reservation?"}, {"role": "assistant", "content": "SELECT reservation_id, guest_id, room_type_id, status, total_amount\nFROM hospitality_technology.reservations\nWHERE num_adults > 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.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.reviews ( review_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, reservation_id character varying(64) UNIQUE, guest_id character varying(64) NOT NULL, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source character varying(100), review_date timestamp with time zone NOT NULL DEFAULT current_timestamp, is_public boolean DEFAULT true, staff_response text, response_staff_id character varying(64), response_date timestamp with time zone, PRIMARY KEY (review_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (response_staff_id) REFERENCES hospitality_technology.staff(staff_id) )\n"}
{"conversations": [{"role": "user", "content": "Show me the top 3 tokens by USD value inflow where smart money was buying (type = 1), along with their token symbol and narrative."}, {"role": "assistant", "content": "SELECT token_symbol, narrative, usd_value FROM smart_money_token_inflow WHERE type = 1 ORDER BY usd_value DESC LIMIT 3;"}, {"role": "user", "content": "Actually, I want to see tokens with a USD value over $100,000."}, {"role": "assistant", "content": "SELECT token_symbol, narrative, usd_value FROM smart_money_token_inflow WHERE type = 1 AND usd_value > 100000 ORDER BY usd_value DESC LIMIT 3;"}, {"role": "user", "content": "Can you filter these results to only include tokens from the Ethereum chain?"}, {"role": "assistant", "content": "SELECT token_symbol, narrative, usd_value FROM smart_money_token_inflow WHERE type = 1 AND usd_value > 100000 AND chain = 'Ethereum' ORDER BY usd_value DESC LIMIT 3;"}, {"role": "user", "content": "Now include the 24-hour trading volume for these tokens from the token_dexpool_info table."}, {"role": "assistant", "content": "SELECT smti.token_symbol, smti.narrative, smti.usd_value, tdi.volume_24h FROM smart_money_token_inflow smti LEFT JOIN token_dexpool_info tdi ON smti.token_symbol = tdi.token_symbol AND smti.chain = tdi.chain WHERE smti.type = 1 AND smti.usd_value > 100000 AND smti.chain = 'Ethereum' ORDER BY smti.usd_value DESC LIMIT 3;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\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\n \"CREATE TABLE token_basic_info (\",\n    \"coin_id character varying(100) NOT NULL, -- the id of the token\",\n    \"token_name character varying(100) NOT NULL, -- the token's name\",\n    \"token_symbol character varying(100) NOT NULL, -- the token's symbol\",\n    \"token_address character varying(100) NOT NULL, -- the token's address\",\n    \"chain text, -- the chain that the token resides\",\n    \"price double precision, -- the current price of the token\",\n    \"price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour\",\n    \"price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours\",\n    \"price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days\",\n    \"highest_price_24h double precision, -- the highest price of the token in 24 hours\",\n    \"lowest_price_24h double precision,  -- the lowest price of the token in 24 hours\",\n    \"market_cap double precision, -- the market cap of the token\",\n    \"market_cap_rank bigint, -- the rank of the token market cap in desc\",\n    \"market_cap_change_percentage_24h text, -- the percentage of market cap changes in 24 hours\",\n    \"total_volume text, -- the trade volum of the token both in decentralized exchange(DEX) and centralized exchange(CEX)\",    \n    \"narrative text, -- the category or narrative of the token\",\n    \"trend_rank biging, -- the trending rank of the token, value 1 expresses the most popular token.\",\n    \",PRIMARY KEY (coin_id, chain));\",\n\n  \"CREATE TABLE token_dexpool_info (\",\n    \"pair_address character varying(512) NOT NULL, -- the id of dexpool\",\n    \"token_name character varying(100) NOT NULL, -- the name of the token in the dexpool\",\n    \"token_symbol character varying(100) NOT NULL, -- the token's symbol\",\n    \"chain text, -- the chain that the dexpool resides\",\n    \"price double precision, -- the current price of the token\",\n    \"price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour\",\n    \"price_change_percentage_6h double precision, -- change in value divided by the absolute price value of the original token price in 6 hours\",\n    \"price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours\",\n    \"makers_24h double precision, -- the makers of the dex pool in 24 hours\",\n    \"volume_24h double precision, -- the trade volume of the dex pool in 24 hours\",\n    \"liquidity double precision, -- the liquidity of the dex pool\",\n    \"market_cap double precision, -- the market cap of the token\",\n    \"trend_rank bigint, -- the rank of token in the dex pool of recent trending, value 1 expresses the most popular token.\",\n    \",PRIMARY KEY (pair_address, chain);\"\n\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  \"CREATE TABLE smart_money_profit (\",\n    \"address character varying(100) NOT NULL, -- the user's address\",\n    \"rank INT, -- the rank of the address in trade performance, value 1 expresses the best address.\",\n    \"profit numeric(38,6), -- the profit user made in a month\",\n    \"roi numeric(38,2), -- the roi of the user in a month\",\n    \"realized_ratio numeric(38,2), -- the percentage of the user's realized profit\",\n    \"most_profit_token character varying(100), -- the token symbol of the user's most profitable trade\",\n    \"last_trade_time character varying(100), -- the last trade time of the user\",\n    \"chain character varying(100), -- the chain that the address resides\",\n    \"PRIMARY KEY (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": "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": "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 me the make and model of vehicles along with the route number and distance for all routes that are serviced by vehicles with a fuel_type of 'Electric'."}, {"role": "assistant", "content": "SELECT v.make, v.model, r.route_number, r.distance_km\nFROM transportation.vehicles v\nJOIN transportation.routes r ON v.vehicle_id = r.route_id\nWHERE v.fuel_type = 'Electric';"}, {"role": "user", "content": "Oops, I want to include the estimated duration for each route as well, and only show routes where the estimated duration is less than 90 minutes."}, {"role": "assistant", "content": "SELECT v.make, v.model, r.route_number, r.distance_km, r.estimated_duration_minutes\nFROM transportation.vehicles v\nJOIN transportation.routes r ON v.vehicle_id = r.route_id\nWHERE v.fuel_type = 'Electric' AND r.estimated_duration_minutes < 90;"}], "system": "You are an SQL statement expert. Given the table structure 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 (\n    driver_id character varying(64) NOT NULL,  -- unique identifier for the driver\n    employee_id character varying(64) NOT NULL UNIQUE, -- employee reference number\n    first_name character varying(128) NOT NULL, -- driver's first name\n    last_name character varying(128) NOT NULL, -- driver's last name\n    license_number character varying(64) NOT NULL UNIQUE, -- driving license number\n    license_expiry_date date NOT NULL, -- expiry date of the license\n    contact_number character varying(32), -- phone number\n    email character varying(128) UNIQUE, -- email address\n    hire_date date NOT NULL, -- date the driver was hired\n    status character varying(32) NOT NULL, -- e.g., Active, On Leave, Terminated\n    PRIMARY KEY (driver_id)\n)\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.maintenance_logs ( log_id.text, vehicle_id.text, service_date.date, odometer_reading.integer, service_type.text, description.text, cost.numeric, mechanic_name.text, next_service_due_date.date )\nCREATE TABLE transportation.fuel_logs ( fuel_log_id text, vehicle_id text, trip_id text, log_timestamp timestamp, fuel_type text, quantity numeric, unit text, cost_per_unit numeric, total_cost numeric, odometer_reading integer, location_id text )\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": "For each Avalanche token tick, calculate the total transfer volume and transaction count over the past 7 days using token_activities_avalanche. Include the token tick, total_volume, and tx_count."}, {"role": "assistant", "content": "SELECT\n  tick,\n  SUM(amt) AS total_volume,\n  COUNT(*) AS tx_count\nFROM token_activities_avalanche\nWHERE block_timestamp >= CURRENT_DATE - INTERVAL '7 days'\nGROUP BY tick;"}, {"role": "user", "content": "Also include the creator address from token_info for each tick, and filter where total_volume > 1000 and creator starts with '0x1'."}, {"role": "assistant", "content": "SELECT\n  a.tick,\n  SUM(a.amt) AS total_volume,\n  COUNT(*) AS tx_count,\n  i.creator\nFROM token_activities_avalanche a\nJOIN token_info i\n  ON a.tick = i.tick\nWHERE a.block_timestamp >= CURRENT_DATE - INTERVAL '7 days'\nGROUP BY a.tick, i.creator\nHAVING SUM(a.amt) > 1000\n  AND i.creator LIKE '0x1%';"}, {"role": "user", "content": "Sort the results by total_volume descending and limit to the top 5 tokens."}, {"role": "assistant", "content": "SELECT\n  a.tick,\n  SUM(a.amt) AS total_volume,\n  COUNT(*) AS tx_count,\n  i.creator\nFROM token_activities_avalanche a\nJOIN token_info i\n  ON a.tick = i.tick\nWHERE a.block_timestamp >= CURRENT_DATE - INTERVAL '7 days'\nGROUP BY a.tick, i.creator\nHAVING SUM(a.amt) > 1000\n  AND i.creator LIKE '0x1%'\nORDER BY total_volume 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 token_metas ( block_timestamp.timestamp, block_number.bigint, transaction_hash.text, transaction_index.bigint, from_address.text, contract_address.text, symbol.text, total_supply.text, name.text, decimals.bigint, is_erc20.integer, is_erc721.integer, is_erc1155.integer, is_proxy.integer, extra_info.text, pk.integer )\nCREATE TABLE erc1155_approval_for_all (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction\n    transaction_index integer NOT NULL, -- Index of the transaction within the block\n    transaction_hash varchar(66) NOT NULL, -- Transaction hash\n    log_index integer NOT NULL, -- Log index\n    contract_address varchar(42) NOT NULL  -- Event contract address\n)\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address text, wallet_address text, amount text, pk integer )\nCREATE TABLE nft_holders ( block_number.bigint, contract_address.text, wallet_address.text, token_id.text, contract_type.text, amount.text, pk.text )\nCREATE TABLE nft_holder_historical (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    contract_address varchar NOT NULL, -- Event contract address\n    wallet_address varchar NOT NULL, -- The wallet address for the contract(with bloom filter)\n    token_id varchar NOT NULL, -- NFT token id\n    contract_type varchar NOT NULL, -- NFT contract type\n    amount varchar NOT NULL, -- The quantity held in the wallet\n    pk integer NOT NULL  -- Partition key for the table(floor(block_number / 7200))\n)\nCREATE TABLE sui_coins ( object_id varchar NOT NULL, status varchar NOT NULL, coin_type varchar NOT NULL, balance varchar NOT NULL, owner varchar NOT NULL )\nCREATE TABLE sui_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 varchar NOT NULL, contract_address varchar NOT NULL, token_id varchar NOT NULL, contract_name varchar NOT NULL, erc_type varchar NOT NULL, amount bigint NOT NULL, minter varchar NOT NULL, owner varchar NOT NULL, mint_block_number bigint NOT NULL, mint_time bigint NOT NULL, mint_transaction_hash varchar NOT NULL, mint_price varchar NOT NULL, token_uri varchar NOT NULL, metadata varchar NOT NULL, name varchar NOT NULL, image_uri varchar NOT NULL, traits varchar NOT NULL, updated_at bigint NOT NULL, status varchar NOT NULL, rarity_score real NOT NULL, rarity_rank integer NOT NULL, unique_attribute_count integer NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_prices ( uuid.text, blockchain.text, address.text, decimals.bigint, symbol.text, price.real, timestamp.timestamp )\nCREATE TABLE token_prices_latest ( blockchain.text, address.text, decimals.bigint, symbol.text, price.real, timestamp.timestamp )\nCREATE TABLE token_balances (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Block timestamp containing the transaction\n    tick varchar NOT NULL, -- Token tick\n    wallet_address varchar(42) NOT NULL, -- Address of owner\n    total_supply decimal(38,0) NOT NULL, -- Max supply\n    amount decimal(38,0) NOT NULL  -- The balance of wallet balance at the corresponding block height\n)\nCREATE TABLE token_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_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 )\n"}
{"conversations": [{"role": "user", "content": "Count the total number of chronic diagnoses for each code_type."}, {"role": "assistant", "content": "SELECT\n  code_type,\n  COUNT(*) AS chronic_diagnosis_count\nFROM healthcare.diagnoses\nWHERE is_chronic = TRUE\nGROUP BY code_type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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 )\n"}
{"conversations": [{"role": "user", "content": "For each property, show the most expensive room type by base_rate, including the property name, room type name, and the highest base_rate."}, {"role": "assistant", "content": "SELECT p.property_name,\n       rt.type_name,\n       MAX(rt.base_rate) AS max_base_rate\nFROM hospitality_technology.room_types rt\nJOIN hospitality_technology.properties p\n  ON rt.property_id = p.property_id\nGROUP BY p.property_name;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties ( property_id 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 (\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, 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 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, 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 (\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.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)\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": "I need to identify pairs of verified documents submitted by the same citizen. For each pair, display the citizen_id, the earlier document_id with its verification timestamp, and the later document_id with its verification timestamp."}, {"role": "assistant", "content": "SELECT\n  d1.citizen_id,\n  d1.document_id AS earlier_document_id,\n  d1.verification_timestamp AS earlier_verification,\n  d2.document_id AS later_document_id,\n  d2.verification_timestamp AS later_verification\nFROM government_services.documents d1\nJOIN government_services.documents d2\n  ON d1.citizen_id = d2.citizen_id\n  AND d1.verification_timestamp < d2.verification_timestamp\nWHERE d1.verification_status = 'Verified'\n  AND d2.verification_status = 'Verified';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.documents ( document_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, document_type character varying(100) NOT NULL, file_reference text NOT NULL, upload_timestamp timestamp NOT NULL, expiry_date date, verification_status character varying(30) DEFAULT 'Pending', verified_by_employee_id character varying(64), verification_timestamp timestamp, PRIMARY KEY (document_id) )\n"}
{"conversations": [{"role": "user", "content": "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": "List all time entries for lawyers specializing in 'Criminal Law'. Show the entry ID, the date worked, hours spent, and the first and last name of the lawyer who performed the work."}, {"role": "assistant", "content": "SELECT te.entry_id, te.date_worked, te.hours_spent, l.first_name, l.last_name FROM legal_services.time_entries te JOIN legal_services.lawyers l ON te.lawyer_id = l.lawyer_id WHERE l.specialization = 'Criminal Law';"}], "system": "You are an SQL statement expert. Given the table structure 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)\nCREATE TABLE legal_services.time_entries (\n    entry_id character varying(64) NOT NULL,  -- unique identifier for the time entry\n    case_id character varying(64) NOT NULL, -- FK to cases table\n    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table (who performed the work)\n    date_worked date NOT NULL, -- date the work was performed\n    hours_spent numeric(5, 2) NOT NULL CHECK (hours_spent > 0), -- duration of work in hours (e.g., 1.5 for 1h 30m)\n    billing_rate numeric(10, 2) NOT NULL, -- hourly rate applied for this entry\n    description text NOT NULL, -- detailed description of the work performed\n    is_billable boolean DEFAULT true, -- whether this time entry is billable to the client\n    is_billed boolean DEFAULT false, -- whether this entry has been included in an invoice\n    invoice_id character varying(64), -- FK to invoices table (once billed)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the entry was recorded\n    PRIMARY KEY (entry_id)\n)\nCREATE TABLE legal_services.invoices (\n    invoice_id character varying(64) NOT NULL,  -- unique identifier for the invoice\n    invoice_number character varying(100) UNIQUE NOT NULL, -- user-facing invoice number\n    client_id character varying(64) NOT NULL, -- FK to clients table\n    case_id character varying(64), -- FK to cases table (optional, could be general retainer)\n    issue_date date NOT NULL, -- date the invoice was generated\n    due_date date NOT NULL, -- date the payment is due\n    total_amount numeric(12, 2) NOT NULL, -- total amount due on the invoice\n    amount_paid numeric(12, 2) DEFAULT 0.00, -- amount already paid\n    status character varying(50) NOT NULL, -- e.g., Draft, Sent, Paid, Partially Paid, Overdue, Void\n    payment_date timestamp, -- date the invoice was fully paid (nullable)\n    notes text, -- additional notes or terms on the invoice\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,\n    PRIMARY KEY (invoice_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Identify all instances where a vehicle's odometer_reading increased by more than 500 miles between two consecutive fuel log entries."}, {"role": "assistant", "content": "SELECT a.vehicle_id,\n       a.fuel_log_id                         AS previous_log_id,\n       b.fuel_log_id                         AS next_log_id,\n       a.log_timestamp                       AS previous_time,\n       b.log_timestamp                       AS next_time,\n       b.odometer_reading - a.odometer_reading AS mile_increase\nFROM transportation.fuel_logs a\nJOIN transportation.fuel_logs b\n  ON a.vehicle_id = b.vehicle_id\n AND b.log_timestamp = (\n      SELECT MIN(log_timestamp)\n      FROM transportation.fuel_logs\n      WHERE vehicle_id = a.vehicle_id\n        AND log_timestamp > a.log_timestamp\n    )\nWHERE b.odometer_reading - a.odometer_reading > 500;"}, {"role": "user", "content": "Now restrict these increases to those where the time difference between entries is less than 7 days."}, {"role": "assistant", "content": "SELECT a.vehicle_id,\n       a.fuel_log_id                         AS previous_log_id,\n       b.fuel_log_id                         AS next_log_id,\n       a.log_timestamp                       AS previous_time,\n       b.log_timestamp                       AS next_time,\n       b.odometer_reading - a.odometer_reading AS mile_increase,\n       EXTRACT(epoch FROM (b.log_timestamp - a.log_timestamp))/3600 AS hours_diff\nFROM transportation.fuel_logs a\nJOIN transportation.fuel_logs b\n  ON a.vehicle_id = b.vehicle_id\n AND b.log_timestamp = (\n      SELECT MIN(log_timestamp)\n      FROM transportation.fuel_logs\n      WHERE vehicle_id = a.vehicle_id\n        AND log_timestamp > a.log_timestamp\n    )\nWHERE b.odometer_reading - a.odometer_reading > 500\n  AND b.log_timestamp - a.log_timestamp < INTERVAL '7 days';"}, {"role": "user", "content": "Also include both the mile increase and the time difference in hours in the final output columns."}, {"role": "assistant", "content": "SELECT a.vehicle_id,\n       a.fuel_log_id                         AS previous_log_id,\n       b.fuel_log_id                         AS next_log_id,\n       b.odometer_reading - a.odometer_reading AS mile_increase,\n       EXTRACT(epoch FROM (b.log_timestamp - a.log_timestamp))/3600 AS hours_difference\nFROM transportation.fuel_logs a\nJOIN transportation.fuel_logs b\n  ON a.vehicle_id = b.vehicle_id\n AND b.log_timestamp = (\n      SELECT MIN(log_timestamp)\n      FROM transportation.fuel_logs\n      WHERE vehicle_id = a.vehicle_id\n        AND log_timestamp > a.log_timestamp\n    )\nWHERE b.odometer_reading - a.odometer_reading > 500\n  AND b.log_timestamp - a.log_timestamp < 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 transportation.fuel_logs ( fuel_log_id.text, vehicle_id.text, trip_id.text, log_timestamp.timestamp, fuel_type.text, quantity.numeric, unit.text, cost_per_unit.numeric, total_cost.numeric, odometer_reading.integer, location_id.text )\n"}
{"conversations": [{"role": "user", "content": "List properties and the average base rate of their room types."}, {"role": "assistant", "content": "SELECT T1.property_name ,  AVG(T2.base_rate) FROM hospitality_technology.properties AS T1 JOIN hospitality_technology.room_types AS T2 ON T1.property_id  =  T2.property_id GROUP BY T1.property_name"}, {"role": "user", "content": "Filter to only show properties where the average base rate is above 250."}, {"role": "assistant", "content": "SELECT T1.property_name ,  AVG(T2.base_rate) FROM hospitality_technology.properties AS T1 JOIN hospitality_technology.room_types AS T2 ON T1.property_id  =  T2.property_id GROUP BY T1.property_name HAVING AVG(T2.base_rate)  >  250"}, {"role": "user", "content": "Also, only include properties in 'New York' or 'Florida' and order by average base rate descending."}, {"role": "assistant", "content": "SELECT T1.property_name ,  AVG(T2.base_rate) AS avg_base_rate FROM hospitality_technology.properties AS T1 JOIN hospitality_technology.room_types AS T2 ON T1.property_id  =  T2.property_id WHERE T1.state IN ('New York', 'Florida') GROUP BY T1.property_name HAVING AVG(T2.base_rate)  >  250 ORDER BY avg_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.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": "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": "For each developer, can you find the next developer in the same country using a self join, returning developer_ids and names?"}, {"role": "assistant", "content": "SELECT d1.developer_id   AS current_dev,\n       d1.name           AS current_name,\n       d2.developer_id   AS next_dev,\n       d2.name           AS next_name,\n       d2.founded_year - d1.founded_year AS years_diff\nFROM developers d1\nJOIN developers d2\n  ON d1.country = d2.country\n  AND d2.founded_year > d1.founded_year;"}, {"role": "user", "content": "Exclude developers who don't have a next developer, and ensure we only pick the closest next by founded_year."}, {"role": "assistant", "content": "SELECT d1.developer_id   AS current_dev,\n       d1.name           AS current_name,\n       d2.developer_id   AS next_dev,\n       d2.name           AS next_name,\n       d2.founded_year - d1.founded_year AS years_diff\nFROM developers d1\nJOIN LATERAL (\n  SELECT d2.developer_id, d2.name, d2.founded_year\n  FROM developers d2\n  WHERE d2.country = d1.country\n    AND d2.founded_year > d1.founded_year\n  ORDER BY d2.founded_year ASC\n  LIMIT 1\n) d2 ON true;"}, {"role": "user", "content": "Finally, only include pairs where the difference in founded years is at most 5 years."}, {"role": "assistant", "content": "SELECT d1.developer_id   AS current_dev,\n       d1.name           AS current_name,\n       d2.developer_id   AS next_dev,\n       d2.name           AS next_name,\n       d2.founded_year - d1.founded_year AS years_diff\nFROM developers d1\nJOIN LATERAL (\n  SELECT d2.developer_id, d2.name, d2.founded_year\n  FROM developers d2\n  WHERE d2.country = d1.country\n    AND d2.founded_year > d1.founded_year\n  ORDER BY d2.founded_year ASC\n  LIMIT 1\n) d2 ON true\nWHERE (d2.founded_year - d1.founded_year) <= 5\nORDER BY d1.developer_id, years_diff ASC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.developers ( developer_id uuid PRIMARY KEY, name text, country text, founded_year int, website text, created_at timestamptz )\n"}
{"conversations": [{"role": "user", "content": "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": "I’d like to find all pairs of securities that belong to the same sector."}, {"role": "assistant", "content": "SELECT a.security_id, a.ticker_symbol, b.security_id AS pair_security_id, b.ticker_symbol AS pair_ticker_symbol, a.sector\nFROM financial_services.securities a\nJOIN financial_services.securities b ON a.sector = b.sector\nWHERE a.security_id < b.security_id;"}, {"role": "user", "content": "Actually, only include pairs where the two securities are listed on different exchanges."}, {"role": "assistant", "content": "SELECT a.security_id, a.ticker_symbol, a.exchange AS exchange_a, b.security_id AS pair_security_id, b.ticker_symbol AS pair_ticker_symbol, b.exchange AS exchange_b, a.sector\nFROM financial_services.securities a\nJOIN financial_services.securities b ON a.sector = b.sector AND a.security_id < b.security_id\nWHERE a.exchange <> b.exchange;"}, {"role": "user", "content": "Also, I want the results sorted by sector, then by exchange_a."}, {"role": "assistant", "content": "SELECT a.security_id, a.ticker_symbol, a.exchange AS exchange_a, b.security_id AS pair_security_id, b.ticker_symbol AS pair_ticker_symbol, b.exchange AS exchange_b, a.sector\nFROM financial_services.securities a\nJOIN financial_services.securities b ON a.sector = b.sector AND a.security_id < b.security_id\nWHERE a.exchange <> b.exchange\nORDER BY a.sector, a.exchange;"}, {"role": "user", "content": "One more thing: include both exchanges in the ORDER BY so that within each sector it’s sorted by exchange_a then exchange_b."}, {"role": "assistant", "content": "SELECT a.security_id, a.ticker_symbol, a.exchange AS exchange_a, b.security_id AS pair_security_id, b.ticker_symbol AS pair_ticker_symbol, b.exchange AS exchange_b, a.sector\nFROM financial_services.securities a\nJOIN financial_services.securities b ON a.sector = b.sector AND a.security_id < b.security_id\nWHERE a.exchange <> b.exchange\nORDER BY a.sector, a.exchange, b.exchange;"}], "system": "You are an SQL statement expert. Given the table structure 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.securities ( security_id text PRIMARY KEY, 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 )\n"}
{"conversations": [{"role": "user", "content": "Find all pairs of different insurance records that share the same group_number, and show group_number, the patient_insurance_id of both records, and their corresponding patient_ids."}, {"role": "assistant", "content": "SELECT a.group_number,\n       a.patient_insurance_id AS pi_id1,\n       a.patient_id            AS patient1_id,\n       b.patient_insurance_id AS pi_id2,\n       b.patient_id            AS patient2_id\nFROM healthcare.patient_insurance a\nJOIN healthcare.patient_insurance b\n  ON a.group_number = b.group_number\n AND a.patient_insurance_id < b.patient_insurance_id\nWHERE a.group_number 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 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 the name, address line 1, and city for all locations located in California."}, {"role": "assistant", "content": "SELECT name, address_line1, city FROM transportation.locations WHERE state_province = 'CA'"}], "system": "You are an SQL statement expert. Given the table structure 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": "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": "Show all routes including their number, type, and description."}, {"role": "assistant", "content": "SELECT route_number ,  type ,  description FROM transportation.routes"}, {"role": "user", "content": "Only show routes of type 'City Bus'."}, {"role": "assistant", "content": "SELECT route_number ,  type ,  description FROM transportation.routes WHERE type  =  'City Bus'"}, {"role": "user", "content": "For these 'City Bus' routes, include the origin and destination city names."}, {"role": "assistant", "content": "SELECT T1.route_number ,  T1.type ,  T1.description ,  T2.city AS origin_city ,  T3.city AS destination_city FROM transportation.routes AS T1 JOIN transportation.locations AS T2 ON T1.origin_location_id  =  T2.location_id JOIN transportation.locations AS T3 ON T1.destination_location_id  =  T3.location_id WHERE T1.type  =  'City Bus'"}, {"role": "user", "content": "Order the results by route number in ascending order and limit to the first 10."}, {"role": "assistant", "content": "SELECT T1.route_number ,  T1.type ,  T1.description ,  T2.city AS origin_city ,  T3.city AS destination_city FROM transportation.routes AS T1 JOIN transportation.locations AS T2 ON T1.origin_location_id  =  T2.location_id JOIN transportation.locations AS T3 ON T1.destination_location_id  =  T3.location_id WHERE T1.type  =  'City Bus' ORDER BY T1.route_number 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 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 (\n    driver_id character varying(64) NOT NULL,  -- unique identifier for the driver\n    employee_id character varying(64) NOT NULL UNIQUE, -- employee reference number\n    first_name character varying(128) NOT NULL, -- driver's first name\n    last_name character varying(128) NOT NULL, -- driver's last name\n    license_number character varying(64) NOT NULL UNIQUE, -- driving license number\n    license_expiry_date date NOT NULL, -- expiry date of the license\n    contact_number character varying(32), -- phone number\n    email character varying(128) UNIQUE, -- email address\n    hire_date date NOT NULL, -- date the driver was hired\n    status character varying(32) NOT NULL, -- e.g., Active, On Leave, Terminated\n    PRIMARY KEY (driver_id)\n)\nCREATE TABLE transportation.routes (\n    route_id character varying(64) NOT NULL,  -- unique identifier for the route\n    route_number character varying(32) NOT NULL UNIQUE, -- public-facing route number/name\n    description text, -- description of the route\n    origin_location_id character varying(64) NOT NULL, -- identifier of the starting location\n    destination_location_id character varying(64) NOT NULL, -- identifier of the ending location\n    distance_km numeric(10, 2), -- estimated distance in kilometers\n    estimated_duration_minutes integer, -- estimated travel time in minutes\n    type character varying(32) NOT NULL, -- e.g., City Bus, Intercity Train, Cargo Delivery\n    PRIMARY KEY (route_id)\n)\nCREATE TABLE transportation.locations (\n    location_id character varying(64) NOT NULL,  -- unique identifier for the location\n    name character varying(255) NOT NULL, -- name of the location (e.g., Central Station, Depot Alpha, Pier 7)\n    type character varying(64) NOT NULL, -- e.g., Station, Stop, Depot, Port, Airport, Customer Address\n    address_line1 character varying(255), -- street address\n    city character varying(128), -- city name\n    state_province character varying(128), -- state or province\n    postal_code character varying(32), -- postal code\n    country character varying(64) NOT NULL, -- country name\n    latitude numeric(9, 6), -- geographic latitude\n    longitude numeric(9, 6), -- geographic longitude\n    timezone character varying(64), -- IANA timezone name (e.g., America/New_York)\n    PRIMARY KEY (location_id)\n)\nCREATE TABLE transportation.fuel_logs (\n    fuel_log_id character varying(64) NOT NULL,  -- unique identifier for the fuel log entry\n    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle fueled\n    trip_id character varying(64), -- optional: identifier of the trip during which fueling occurred\n    log_timestamp timestamp with time zone NOT NULL, -- time when fueling occurred\n    fuel_type character varying(32) NOT NULL, -- type of fuel added (matches vehicle's fuel type)\n    quantity numeric(10, 3) NOT NULL, -- amount of fuel added (e.g., Liters, Gallons, kWh)\n    unit character varying(16) NOT NULL, -- unit of quantity (e.g., L, gal, kWh)\n    cost_per_unit numeric(8, 4), -- price per unit of fuel\n    total_cost numeric(10, 2) NOT NULL, -- total cost of the fuel purchase\n    odometer_reading integer, -- vehicle mileage at time of fueling\n    location_id character varying(64), -- identifier of the fueling station/location\n    PRIMARY KEY (fuel_log_id)\n)\n"}
{"conversations": [{"role": "user", "content": "For wallet '0x...', list the token IDs of the NFTs currently held, the name of their collection, and that collection's floor price."}, {"role": "assistant", "content": "SELECT T1.token_id, T2.name, T2.floor_price FROM nft_holders AS T1 INNER JOIN nft_collections AS T2 ON T1.contract_address = T2.contract_address WHERE T1.wallet_address = '0x...';"}], "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 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_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )\nCREATE TABLE nft_collections ( blockchain text, contract_address text, name text, symbol text, deploy_block_number bigint, deploy_block_time bigint, erc_type text, owner text, traits text, description text, slug text, media_info text, image_url text, banner_image_url text, updated_at bigint, banner text, token_count bigint, floor_price text, floor_price_symbol text, floor_price_contract text, pk integer )\nCREATE TABLE token_prices ( 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_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 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": "List the full name and bar number of all lawyers who were hired before 2015."}, {"role": "assistant", "content": "SELECT first_name || ' ' || last_name AS lawyer_full_name, bar_number\nFROM legal_services.lawyers\nWHERE hire_date < '2015-01-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.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.cases ( case_id character varying(64) NOT NULL, case_number character varying(100) UNIQUE, case_name text NOT NULL, client_id character varying(64) NOT NULL, lead_lawyer_id character varying(64) NOT NULL, case_type character varying(100) NOT NULL, status character varying(50) NOT NULL, date_opened timestamp NOT NULL, date_closed timestamp, description text, court_jurisdiction character varying(128), PRIMARY KEY (case_id) )\nCREATE TABLE legal_services.invoices ( invoice_id character varying(64) NOT NULL, invoice_number character varying(100) UNIQUE NOT NULL, client_id character varying(64) NOT NULL, case_id character varying(64), issue_date date NOT NULL, due_date date NOT NULL, total_amount numeric(12, 2) NOT NULL, amount_paid numeric(12, 2) DEFAULT 0.00, status character varying(50) NOT NULL, payment_date timestamp, notes text, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (invoice_id) )\n"}
{"conversations": [{"role": "user", "content": "For each block number, show the highest transaction value and the status of the transaction with the highest value."}, {"role": "assistant", "content": "SELECT t.block_number, t.value AS max_value, t.status\nFROM web3.transactions t\nJOIN (\n  SELECT block_number, MAX(value) AS max_value\n  FROM web3.transactions\n  GROUP BY block_number\n) mv\n  ON t.block_number = mv.block_number AND t.value = mv.max_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.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": "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": "Provide a count of citizens registered per calendar year."}, {"role": "assistant", "content": "SELECT CAST(EXTRACT(YEAR FROM registration_date) AS INTEGER) AS registration_year, COUNT(*) AS citizen_count FROM government_services.citizens 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 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": "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": "For each asset, I want to know how many orders have the status 'filled', showing the asset symbol."}, {"role": "assistant", "content": "SELECT m.value AS asset_symbol,\n       COUNT(*) AS filled_order_count\nFROM trading_platform.orders o\nJOIN trading_platform.metadata m\n  ON o.asset_id = m.asset_id\n AND m.key = 'symbol'\nWHERE o.status = 'filled'\nGROUP BY m.value;"}, {"role": "user", "content": "Include assets that have zero filled orders, showing filled_order_count as 0."}, {"role": "assistant", "content": "WITH asset_symbols AS (\n  SELECT DISTINCT asset_id,\n         value AS asset_symbol\n  FROM trading_platform.metadata\n  WHERE key = 'symbol'\n)\nSELECT a.asset_symbol,\n       COALESCE(f.filled_order_count, 0) AS filled_order_count\nFROM asset_symbols a\nLEFT JOIN (\n  SELECT asset_id,\n         COUNT(*) AS filled_order_count\n  FROM trading_platform.orders\n  WHERE status = 'filled'\n  GROUP BY asset_id\n) f\n  ON a.asset_id = f.asset_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.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.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.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": "Show me all insurance plans where the website includes 'secure'."}, {"role": "assistant", "content": "SELECT * FROM healthcare.insurance_plans WHERE website ILIKE '%secure%';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.doctors ( doctor_id text, first_name text, last_name text, specialty text, license_number text, phone_number text, email text, hospital_affiliation_id text, created_at timestamp, updated_at timestamp )\nCREATE TABLE healthcare.medical_records ( record_id text PRIMARY KEY, patient_id text, appointment_id text, doctor_id text, record_date timestamp, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals text, created_at timestamp )\nCREATE TABLE healthcare.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )\nCREATE TABLE healthcare.patient_insurance ( patient_insurance_id text, patient_id text, plan_id text, policy_number text, group_number text, subscriber_name text, effective_date date, expiration_date date, is_primary boolean )\n"}
{"conversations": [{"role": "user", "content": "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": "I need to compare consecutive daily close_prices for each security to find when the close_price increased compared to the previous day."}, {"role": "assistant", "content": "SELECT a.security_id, b.data_timestamp AS prev_date, b.close_price AS prev_close, a.data_timestamp AS curr_date, a.close_price AS curr_close\nFROM financial_services.market_data a\nJOIN financial_services.market_data b\n  ON a.security_id = b.security_id\n  AND CAST(a.data_timestamp AS date) = CAST(b.data_timestamp + INTERVAL '1 day' AS date)\nWHERE a.close_price > b.close_price;"}, {"role": "user", "content": "Now, restrict this to only securities whose average volume over the past 30 days exceeds 1,000,000."}, {"role": "assistant", "content": "WITH high_vol AS (\n  SELECT security_id\n  FROM financial_services.market_data\n  WHERE data_timestamp >= NOW() - INTERVAL '30 days'\n  GROUP BY security_id\n  HAVING AVG(volume) > 1000000\n)\nSELECT a.security_id, b.data_timestamp AS prev_date, b.close_price AS prev_close, a.data_timestamp AS curr_date, a.close_price AS curr_close\nFROM financial_services.market_data a\nJOIN financial_services.market_data b\n  ON a.security_id = b.security_id\n  AND CAST(a.data_timestamp AS date) = CAST(b.data_timestamp + INTERVAL '1 day' AS date)\nJOIN high_vol h\n  ON a.security_id = h.security_id\nWHERE a.close_price > b.close_price;"}, {"role": "user", "content": "Also, only include those increases where the percentage change between days is greater than 2%."}, {"role": "assistant", "content": "WITH high_vol AS (\n  SELECT security_id\n  FROM financial_services.market_data\n  WHERE data_timestamp >= NOW() - INTERVAL '30 days'\n  GROUP BY security_id\n  HAVING AVG(volume) > 1000000\n)\nSELECT a.security_id,\n       b.data_timestamp AS prev_date,\n       b.close_price AS prev_close,\n       a.data_timestamp AS curr_date,\n       a.close_price AS curr_close,\n       ROUND((a.close_price - b.close_price) / b.close_price * 100, 2) AS pct_change\nFROM financial_services.market_data a\nJOIN financial_services.market_data b\n  ON a.security_id = b.security_id\n  AND CAST(a.data_timestamp AS date) = CAST(b.data_timestamp + INTERVAL '1 day' AS date)\nJOIN high_vol h\n  ON a.security_id = h.security_id\nWHERE (a.close_price - b.close_price) / b.close_price * 100 > 2;"}, {"role": "user", "content": "Finally, add the adjusted_close_price for both current and previous days to the result."}, {"role": "assistant", "content": "WITH high_vol AS (\n  SELECT security_id\n  FROM financial_services.market_data\n  WHERE data_timestamp >= NOW() - INTERVAL '30 days'\n  GROUP BY security_id\n  HAVING AVG(volume) > 1000000\n)\nSELECT a.security_id,\n       b.data_timestamp AS prev_date,\n       b.close_price AS prev_close,\n       b.adjusted_close_price AS prev_adj_close,\n       a.data_timestamp AS curr_date,\n       a.close_price AS curr_close,\n       a.adjusted_close_price AS curr_adj_close,\n       ROUND((a.close_price - b.close_price) / b.close_price * 100, 2) AS pct_change\nFROM financial_services.market_data a\nJOIN financial_services.market_data b\n  ON a.security_id = b.security_id\n  AND CAST(a.data_timestamp AS date) = CAST(b.data_timestamp + INTERVAL '1 day' AS date)\nJOIN high_vol h\n  ON a.security_id = h.security_id\nWHERE (a.close_price - b.close_price) / b.close_price * 100 > 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 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 )\n"}
{"conversations": [{"role": "user", "content": "Find the contract address and name for all NFT collections listed on the 'Ethereum' blockchain."}, {"role": "assistant", "content": "SELECT contract_address, name FROM nft_collections WHERE blockchain = 'Ethereum'"}, {"role": "user", "content": "For these collections, can you show the count of unique wallet addresses holding NFTs in each collection by joining with nft_holders?"}, {"role": "assistant", "content": "SELECT T1.contract_address, T1.name, COUNT(DISTINCT T2.wallet_address) AS unique_holder_count FROM nft_collections AS T1 JOIN nft_holders AS T2 ON T1.contract_address = T2.contract_address WHERE T1.blockchain = 'Ethereum' GROUP BY T1.contract_address, T1.name"}, {"role": "user", "content": "Please filter the results to only include collections that have more than 100 unique holders."}, {"role": "assistant", "content": "SELECT T1.contract_address, T1.name, COUNT(DISTINCT T2.wallet_address) AS unique_holder_count FROM nft_collections AS T1 JOIN nft_holders AS T2 ON T1.contract_address = T2.contract_address WHERE T1.blockchain = 'Ethereum' GROUP BY T1.contract_address, T1.name HAVING COUNT(DISTINCT T2.wallet_address) > 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(6) NOT NULL, block_number bigint NOT NULL, transaction_hash varchar NOT NULL, transaction_index bigint NOT NULL, from_address varchar NOT NULL, contract_address varchar NOT NULL, symbol varchar NOT NULL, total_supply varchar NOT NULL, name varchar NOT NULL, decimals bigint NOT NULL, is_erc20 integer NOT NULL, is_erc721 integer NOT NULL, is_erc1155 integer NOT NULL, is_proxy integer NOT NULL, extra_info varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE nft_holder_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE sui_coins ( object_id varchar NOT NULL, status varchar NOT NULL, coin_type varchar NOT NULL, balance varchar NOT NULL, owner varchar NOT NULL )\nCREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_prices ( uuid varchar(36) NOT NULL, blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )\nCREATE TABLE token_prices_latest ( blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )\nCREATE TABLE token_info ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL )\nCREATE TABLE token_activities ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar NOT NULL, tick varchar NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(42) NOT NULL, to_address varchar(42) NOT NULL )\nCREATE TABLE token_balances_bitcoin ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar(255) NOT NULL, wallet_address varchar(42) NOT NULL, total_supply varchar NOT NULL, amount varchar NOT NULL )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(62) NOT NULL, to_address varchar(62) NOT NULL )\nCREATE TABLE token_activities_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(42) NOT NULL, to_address varchar(42) NOT NULL )\nCREATE TABLE token_balances_avalanche ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar(20) NOT NULL, wallet_address varchar(42) NOT NULL, total_supply decimal(38,0) NOT NULL, amount decimal(38,0) NOT NULL )\nCREATE TABLE token_info_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar(20) NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL, minted decimal(38,0) NOT NULL, holders decimal(38,0) NOT NULL, txs decimal(38,0) NOT NULL, updated_timestamp timestamp(3) NOT NULL, completed_timestamp timestamp(3) NOT NULL, id varchar(255) NOT NULL )\n"}
{"conversations": [{"role": "user", "content": "Show me a list of all properties along with their average overall review rating."}, {"role": "assistant", "content": "SELECT p.property_id, p.property_name, AVG(r.rating_overall) AS avg_rating\nFROM hospitality_technology.properties p\nJOIN hospitality_technology.reviews r ON p.property_id = r.property_id\nGROUP BY p.property_id, p.property_name;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties ( property_id character varying(64) NOT NULL, property_name character varying(255) NOT NULL, address_line1 character varying(255) NOT NULL, address_line2 character varying(255), city character varying(100) NOT NULL, state_province character varying(100), postal_code character varying(20) NOT NULL, country_code character varying(3) NOT NULL, phone_number character varying(30), email_address character varying(255), property_type character varying(50) NOT NULL, star_rating numeric(2,1), timezone character varying(64) NOT NULL, manager_staff_id character varying(64), created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (property_id) )\nCREATE TABLE hospitality_technology.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": "List the total value and count of transactions for each status, ordered by total value descending."}, {"role": "assistant", "content": "SELECT status, COUNT(*) AS transaction_count, SUM(value) AS total_value\nFROM web3.transactions\nGROUP BY status\nORDER BY total_value DESC;"}, {"role": "user", "content": "Actually, can you also include the average value per transaction for each status?"}, {"role": "assistant", "content": "SELECT status, COUNT(*) AS transaction_count, SUM(value) AS total_value, AVG(value) AS avg_value\nFROM web3.transactions\nGROUP BY status\nORDER BY total_value DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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": "Provide a count of how many peers were last seen on each distinct day recorded in the system."}, {"role": "assistant", "content": "SELECT DATE(last_seen), COUNT(*) FROM trading_platform.peers GROUP BY DATE(last_seen) ORDER BY DATE(last_seen);"}], "system": "You are an SQL statement expert. Given the table structure 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 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.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.kyc_audit ( kyc_audit_id text, user_id text, status text, reviewed_at timestamp )\nCREATE TABLE trading_platform.logs ( log_id text, user_id text, action text, details text, logged_at timestamp )\nCREATE TABLE trading_platform.notifications ( notification_id text, user_id text, message text, sent_at timestamp, read_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List the medication_name and manufacturer for all medications where the description is null or an empty string."}, {"role": "assistant", "content": "SELECT medication_name, manufacturer FROM healthcare.medications WHERE description IS NULL OR description = '';"}, {"role": "user", "content": "Now, refine the query to only include medications whose ndc_code starts with '5'."}, {"role": "assistant", "content": "SELECT medication_name, manufacturer FROM healthcare.medications WHERE (description IS NULL OR description = '') AND ndc_code LIKE '5%';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.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": "Give me the total number of reservations and the sum of total_amount by month for the year 2023."}, {"role": "assistant", "content": "SELECT DATE_TRUNC('month', check_in_date) AS month,\n       COUNT(*)                         AS reservation_count,\n       SUM(total_amount)               AS total_revenue\nFROM hospitality_technology.reservations\nWHERE EXTRACT(YEAR FROM check_in_date) = 2023\nGROUP BY DATE_TRUNC('month', check_in_date)\nORDER BY month;"}, {"role": "user", "content": "Actually, I only want reservations with status 'CheckedOut' or 'Completed'."}, {"role": "assistant", "content": "SELECT DATE_TRUNC('month', check_in_date) AS month,\n       COUNT(*)                         AS reservation_count,\n       SUM(total_amount)               AS total_revenue\nFROM hospitality_technology.reservations\nWHERE EXTRACT(YEAR FROM check_in_date) = 2023\n  AND status IN ('CheckedOut', 'Completed')\nGROUP BY DATE_TRUNC('month', check_in_date)\nORDER BY month;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.reservations ( reservation_id text PRIMARY KEY, property_id text, guest_id text, room_id text, room_type_id text, check_in_date date, check_out_date date, actual_check_in_ts timestamp, actual_check_out_ts timestamp, num_adults int, num_children int, status text, booking_source text, rate_plan_id text, total_amount numeric, amount_paid numeric, special_requests text, created_at timestamp, updated_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "What is the total amount of all payments recorded?"}, {"role": "assistant", "content": "SELECT SUM(amount) FROM government_services.payments;"}, {"role": "user", "content": "Now only include payments with status 'Completed'."}, {"role": "assistant", "content": "SELECT SUM(amount) FROM government_services.payments WHERE status = 'Completed';"}, {"role": "user", "content": "Also, only consider payments made in the year 2024."}, {"role": "assistant", "content": "SELECT SUM(amount) FROM government_services.payments WHERE status = 'Completed' AND EXTRACT(YEAR FROM payment_timestamp) = 2024;"}, {"role": "user", "content": "Group the results by payment method and show the total amount for each method for these completed 2024 payments."}, {"role": "assistant", "content": "SELECT payment_method, SUM(amount) FROM government_services.payments WHERE status = 'Completed' AND EXTRACT(YEAR FROM payment_timestamp) = 2024 GROUP 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 government_services.citizens ( citizen_id text PRIMARY KEY, national_id_number text, first_name text, last_name text, date_of_birth date, gender text, primary_address text, contact_email text, contact_phone text, registration_date timestamp, is_verified boolean )\nCREATE TABLE government_services.services ( service_id text PRIMARY KEY, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days int, is_active boolean, online_application_url text )\nCREATE TABLE government_services.payments ( payment_id text PRIMARY KEY, application_id text, citizen_id text, service_id text, amount numeric, currency text, payment_method text, payment_provider_reference text, payment_timestamp timestamp, status text, notes text )\nCREATE TABLE government_services.service_locations ( location_id text PRIMARY KEY, agency_id text, location_name text, address text, city text, state text, postal_code text, latitude numeric, longitude numeric, operating_hours text, contact_phone text, is_accessible boolean )\nCREATE TABLE government_services.appointments ( appointment_id text PRIMARY KEY, citizen_id text, employee_id text, location_id text, service_id text, scheduled_start_time timestamp, scheduled_end_time timestamp, purpose text, status text, booking_method text, created_at timestamp, notes text )\n"}
{"conversations": [{"role": "user", "content": "Which games have achievements where the points value is exactly 0? List the game title and the achievement name."}, {"role": "assistant", "content": "SELECT g.title AS game_title, a.name AS achievement_name\nFROM gaming_technology.achievements a\nJOIN gaming_technology.games g ON a.game_id = g.game_id\nWHERE a.points = 0;"}, {"role": "user", "content": "Show also the achievement's description and whether it is hidden."}, {"role": "assistant", "content": "SELECT g.title AS game_title, a.name AS achievement_name, a.description, a.hidden\nFROM gaming_technology.achievements a\nJOIN gaming_technology.games g ON a.game_id = g.game_id\nWHERE a.points = 0;"}, {"role": "user", "content": "Only show achievements released in games before 2020."}, {"role": "assistant", "content": "SELECT g.title AS game_title, a.name AS achievement_name, a.description, a.hidden\nFROM gaming_technology.achievements a\nJOIN gaming_technology.games g ON a.game_id = g.game_id\nWHERE a.points = 0 AND g.release_date < '2020-01-01';"}, {"role": "user", "content": "Sort the results by game_title ascending, then achievement_name ascending."}, {"role": "assistant", "content": "SELECT g.title AS game_title, a.name AS achievement_name, a.description, a.hidden\nFROM gaming_technology.achievements a\nJOIN gaming_technology.games g ON a.game_id = g.game_id\nWHERE a.points = 0 AND g.release_date < '2020-01-01'\nORDER BY g.title ASC, a.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 gaming_technology.players (\n    player_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the player\n    username character varying(100) NOT NULL UNIQUE, -- player's chosen display name\n    email character varying(255) NOT NULL UNIQUE, -- player's email address for login/recovery\n    password_hash text NOT NULL, -- securely hashed password\n    registration_date timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the player account was created\n    last_login timestamp with time zone, -- timestamp of the last successful login\n    country_code character(2), -- player's country (ISO 3166-1 alpha-2)\n    status character varying(20) NOT NULL DEFAULT 'active', -- account status (e.g., active, banned, suspended)\n    profile_data jsonb, -- flexible field for avatar url, bio, preferences etc.\n    PRIMARY KEY (player_id)\n)\nCREATE TABLE gaming_technology.games (\n    game_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game\n    title character varying(200) NOT NULL, -- official title of the game\n    developer_id uuid NOT NULL, -- FK linking to the developers table\n    publisher_id uuid, -- FK linking to a potential publishers table (optional)\n    genre character varying(100), -- primary genre (e.g., RPG, FPS, Strategy)\n    release_date date, -- official release date\n    description text, -- short description or synopsis of the game\n    platform character varying(50) NOT NULL, -- primary platform (e.g., PC, PlayStation 5, Xbox Series X, Mobile)\n    engine character varying(100), -- game engine used (e.g., Unreal Engine 5, Unity)\n    website character varying(255), -- official website URL\n    PRIMARY KEY (game_id)\n    -- FOREIGN KEY (developer_id) REFERENCES gaming_technology.developers(developer_id) -- Example FK constraint\n)\nCREATE TABLE gaming_technology.game_sessions (\n    session_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game session\n    player_id uuid NOT NULL, -- FK linking to the players table\n    game_id uuid NOT NULL, -- FK linking to the games table\n    server_id uuid, -- FK linking to the servers table (nullable for single-player)\n    start_time timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the session began\n    end_time timestamp with time zone, -- when the session ended (null if ongoing)\n    duration_seconds integer, -- calculated duration of the session in seconds\n    score integer, -- player's score for the session, if applicable\n    session_data jsonb, -- flexible field for session-specific info (e.g., map played, character used)\n    PRIMARY KEY (session_id)\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id),\n    -- FOREIGN KEY (server_id) REFERENCES gaming_technology.servers(server_id)\n)\nCREATE TABLE gaming_technology.servers (\n    server_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game server instance\n    game_id uuid NOT NULL, -- FK linking to the game this server hosts\n    server_name character varying(150), -- display name for the server\n    region character varying(50) NOT NULL, -- geographical region (e.g., us-east-1, eu-west-2)\n    ip_address character varying(45), -- IP address (IPv4 or IPv6)\n    port integer, -- network port number\n    current_players integer NOT NULL DEFAULT 0, -- number of players currently connected\n    max_players integer NOT NULL, -- maximum player capacity\n    status character varying(30) NOT NULL DEFAULT 'offline', -- server status (e.g., online, offline, maintenance)\n    last_heartbeat timestamp with time zone, -- last time the server reported its status\n    PRIMARY KEY (server_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.achievements (\n    achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an achievement definition\n    game_id uuid NOT NULL, -- FK linking to the game the achievement belongs to\n    name character varying(150) NOT NULL, -- name of the achievement\n    description text NOT NULL, -- how to unlock the achievement\n    icon_url character varying(255), -- URL for the achievement's icon\n    points integer DEFAULT 0, -- points awarded for unlocking (optional)\n    hidden boolean DEFAULT false, -- whether the achievement details are hidden until unlocked\n    PRIMARY KEY (achievement_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.player_achievements (\n    player_achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for this unlock instance\n    player_id uuid NOT NULL, -- FK linking to the player who unlocked it\n    achievement_id uuid NOT NULL, -- FK linking to the achievement definition\n    unlocked_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the achievement was unlocked\n    PRIMARY KEY (player_achievement_id),\n    UNIQUE (player_id, achievement_id) -- Ensure a player can only unlock an achievement once\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (achievement_id) REFERENCES gaming_technology.achievements(achievement_id)\n)\nCREATE TABLE gaming_technology.in_game_items (\n    item_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the item definition\n    game_id uuid NOT NULL, -- FK linking to the game this item belongs to\n    item_name character varying(150) NOT NULL, -- name of the item\n    item_type character varying(50) NOT NULL, -- type (e.g., Cosmetic, Consumable, Weapon, Armor)\n    description text, -- description of the item\n    rarity character varying(30), -- item rarity (e.g., Common, Rare, Epic, Legendary)\n    cost_currency character varying(10), -- currency code if purchasable (e.g., USD, EUR, GOLD)\n    cost_amount numeric(12, 2), -- price if purchasable\n    attributes jsonb, -- flexible field for item stats or properties\n    PRIMARY KEY (item_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.player_inventory (\n    inventory_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an inventory entry\n    player_id uuid NOT NULL, -- FK linking to the player owning the item\n    item_id uuid NOT NULL, -- FK linking to the item definition\n    quantity integer NOT NULL DEFAULT 1, -- number of items held (for stackable items)\n    acquired_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the item was acquired\n    instance_data jsonb, -- data specific to this instance (e.g., weapon mods, durability)\n    PRIMARY KEY (inventory_id),\n    -- Optional unique constraint if items are non-stackable or unique instances\n    -- UNIQUE (player_id, item_id) -- Use if quantity is always 1\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (item_id) REFERENCES gaming_technology.in_game_items(item_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all agents who have been terminated, showing their full name, agency name, and termination date."}, {"role": "assistant", "content": "SELECT first_name, last_name, agency_name, termination_date\nFROM insurance.agents\nWHERE 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.agents ( agent_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, agency_name character varying(150), license_number character varying(100) NOT NULL UNIQUE, license_state character varying(50) NOT NULL, contact_email character varying(128) UNIQUE, contact_phone character varying(30), hire_date date, termination_date date, status character varying(20) NOT NULL DEFAULT 'Active', commission_rate numeric(5, 4) NOT NULL DEFAULT 0.05, manager_id character varying(64), PRIMARY KEY (agent_id) )\n"}
{"conversations": [{"role": "user", "content": "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": "Could you list all pairs of developers that are based in the same country and share the same website domain?"}, {"role": "assistant", "content": "SELECT\n  d1.name AS developer1_name,\n  d2.name AS developer2_name,\n  d1.country,\n  d1.website\nFROM\n  gaming_technology.developers AS d1\nJOIN\n  gaming_technology.developers AS d2 ON d1.country = d2.country\n  AND d1.website = d2.website\n  AND d1.developer_id < d2.developer_id\nWHERE\n  d1.country IS NOT NULL\n  AND d1.website IS NOT NULL AND d1.website != '';"}], "system": "You are an SQL statement expert. Given the table structure 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 (\n    developer_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the developer studio\n    name character varying(150) NOT NULL UNIQUE, -- name of the development studio\n    country character varying(100), -- country where the studio is based\n    founded_year integer, -- year the studio was founded\n    website character varying(255), -- developer's official website\n    created_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP,\n    PRIMARY KEY (developer_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Count the number of trips for each route type."}, {"role": "assistant", "content": "SELECT R.type, COUNT(T.trip_id) FROM transportation.trips AS T JOIN transportation.routes AS R ON T.route_id = R.route_id GROUP BY R.type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.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.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": "Show the top 5 properties by average overall review rating."}, {"role": "assistant", "content": "SELECT p.property_name, AVG(r.rating_overall) AS avg_rating\nFROM hospitality_technology.properties p\nJOIN hospitality_technology.reviews r\n  ON p.property_id = r.property_id\nGROUP BY p.property_name\nORDER BY avg_rating DESC\nLIMIT 5;"}, {"role": "user", "content": "Only consider reviews that are publicly visible."}, {"role": "assistant", "content": "SELECT p.property_name, AVG(r.rating_overall) AS avg_rating\nFROM hospitality_technology.properties p\nJOIN hospitality_technology.reviews r\n  ON p.property_id = r.property_id\nWHERE r.is_public = true\nGROUP BY p.property_name\nORDER BY avg_rating 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 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.guests (\n    guest_id character varying(64) NOT NULL,  -- unique identifier for the guest profile\n    first_name character varying(100) NOT NULL, -- guest's first name\n    last_name character varying(100) NOT NULL, -- guest's last name\n    email character varying(255) UNIQUE, -- guest's email address (unique identifier?)\n    phone_number character varying(30), -- guest's phone number\n    date_of_birth date, -- guest's date of birth\n    address_line1 character varying(255), -- guest's home address\n    city character varying(100),\n    state_province character varying(100),\n    postal_code character varying(20),\n    country_code character varying(3),\n    preferences text, -- notes on guest preferences (e.g., allergies, room location)\n    loyalty_member_id character varying(64) UNIQUE, -- FK to loyalty_members table\n    communication_consent boolean DEFAULT true, -- consent for marketing communications\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 (guest_id)\n)\nCREATE TABLE hospitality_technology.staff (\n    staff_id character varying(64) NOT NULL,  -- unique identifier for the staff member\n    property_id character varying(64) NOT NULL, -- FK to properties table (primary property)\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    position character varying(100) NOT NULL, -- e.g., Front Desk Agent, Housekeeper, Manager, Concierge\n    work_email character varying(255) UNIQUE, -- staff member's work email\n    work_phone character varying(30),\n    hire_date date NOT NULL,\n    termination_date date, -- date employment ended (if applicable)\n    is_active boolean NOT NULL DEFAULT true, -- currently employed flag\n    access_level integer NOT NULL, -- permission level within systems (e.g., 1=basic, 5=admin)\n    manager_id character varying(64), -- FK to staff table (self-referencing for supervisor)\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (staff_id),\n    FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id),\n    FOREIGN KEY (manager_id) REFERENCES hospitality_technology.staff(staff_id)\n)\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.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": "Which states have the highest number of customers? Provide the top 5 states along with their customer counts, ordered by count descending."}, {"role": "assistant", "content": "SELECT\n  state,\n  COUNT(*) AS customer_count\nFROM insurance.customers\nGROUP BY state\nORDER BY customer_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 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": "Show me all transactions (transaction_id, amount, transaction_type) where the transaction_type is 'Transfer' and the status is 'Completed', along with the account_id and related_account_id."}, {"role": "assistant", "content": "SELECT transaction_id, amount, transaction_type, account_id, related_account_id FROM financial_services.transactions WHERE transaction_type = 'Transfer' AND status = 'Completed';"}, {"role": "user", "content": "Now modify the query to include only transfers with amounts greater than $1,000 and sort them by transaction_date in descending order."}, {"role": "assistant", "content": "SELECT transaction_id, amount, transaction_type, account_id, related_account_id FROM financial_services.transactions WHERE transaction_type = 'Transfer' AND status = 'Completed' AND amount > 1000 ORDER BY transaction_date DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE financial_services.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, 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": "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": "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": "Show me the top 5 users who have interacted with DApps, along with the count of distinct DApps they interacted with and their wallet addresses."}, {"role": "assistant", "content": "SELECT w.user_id, COUNT(DISTINCT d.dapp_id) AS dapp_count, w.address FROM trading_platform.wallets w JOIN trading_platform.dapps d ON 1=1 GROUP BY w.user_id, w.address ORDER BY dapp_count DESC LIMIT 5;"}, {"role": "user", "content": "This query doesn't properly show DApp interactions. Please modify it to correctly join with a table that records user-DApp interactions."}, {"role": "assistant", "content": "I notice there's no interaction table in the provided schema. Without a table recording user-DApp interactions, I cannot generate this query accurately. Would you like to see users who have wallets and DApps separately instead?"}, {"role": "user", "content": "You're right. Instead, show me users who have wallets but have never interacted with any DApps, along with their wallet addresses."}, {"role": "assistant", "content": "SELECT w.user_id, w.address FROM trading_platform.wallets w WHERE NOT EXISTS (SELECT 1 FROM trading_platform.dapps d WHERE 1=1) GROUP BY w.user_id, w.address;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.wallets ( wallet_id.text, user_id.text, address.text, private_key.text, created_at.timestamp )\nCREATE TABLE trading_platform.trades ( trade_id character varying(64) NOT NULL, order_id character varying(64) NOT NULL, buyer_id character varying(64) NOT NULL, seller_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, quantity numeric(38,14) NOT NULL, price numeric(38,14) NOT NULL, traded_at timestamp NOT NULL, PRIMARY KEY (trade_id) )\nCREATE TABLE trading_platform.assets ( asset_id.text, name.text, symbol.text, type.text )\nCREATE TABLE trading_platform.dapps (\n    dapp_id character varying(64) NOT NULL,  -- unique identifier for the DApp\n    name character varying(128) NOT NULL, -- name of the DApp\n    description text NOT NULL, -- description of the DApp\n    url character varying(256) NOT NULL, -- URL of the DApp\n    PRIMARY KEY (dapp_id)\n)\nCREATE TABLE trading_platform.metadata ( metadata_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, key character varying(128) NOT NULL, value text NOT NULL, PRIMARY KEY (metadata_id) )\n"}
{"conversations": [{"role": "user", "content": "What is the current address of the employee with ID 'EMP234'?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide the current address of an employee as this information is not stored in the database 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.text, first_name.text, last_name.text, job_title.text, skill_certifications.text, hire_date.date, assigned_line_id.text, employment_status.text, supervisor_employee_id.text )\n"}
{"conversations": [{"role": "user", "content": "Calculate the total PNL and total Net Flow for all tokens recorded on the 'Arbitrum' chain."}, {"role": "assistant", "content": "SELECT SUM(pnl) as total_pnl, SUM(net_flow) as total_net_flow FROM smart_money_token_performance WHERE chain = 'Arbitrum';"}, {"role": "user", "content": "Can you calculate the total PNL and total Net Flow for *all* chains? Show the chain, total PNL, and total Net Flow, ordered by total PNL in descending order."}, {"role": "assistant", "content": "SELECT chain, SUM(pnl) as total_pnl, SUM(net_flow) as total_net_flow FROM smart_money_token_performance GROUP BY chain ORDER BY total_pnl 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_performance ( token_address character varying(100) NOT NULL, token_symbol character varying(100), pnl numeric(38,2), net_flow numeric(38,2), avg_cost numeric(38,16), price double precision, realized_ratio numeric(10,2), roi numeric(10,2), chain character varying(100) )\n"}
{"conversations": [{"role": "user", "content": "For each asset, show its name and symbol, and the total number of completed orders that have resulted in at least one trade."}, {"role": "assistant", "content": "SELECT a.name, a.symbol, COUNT(DISTINCT o.order_id) AS completed_order_count\nFROM trading_platform.assets a\nJOIN trading_platform.orders o ON o.asset_id = a.asset_id AND o.status = 'filled'\nJOIN trading_platform.trades t ON t.order_id = o.order_id\nGROUP BY a.asset_id, a.name, a.symbol;"}, {"role": "user", "content": "Only include assets where the total number of completed orders with trades is greater than 5, and sort the results by completed_order_count descending."}, {"role": "assistant", "content": "SELECT a.name, a.symbol, COUNT(DISTINCT o.order_id) AS completed_order_count\nFROM trading_platform.assets a\nJOIN trading_platform.orders o ON o.asset_id = a.asset_id AND o.status = 'filled'\nJOIN trading_platform.trades t ON t.order_id = o.order_id\nGROUP BY a.asset_id, a.name, a.symbol\nHAVING COUNT(DISTINCT o.order_id) > 5\nORDER BY completed_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": "For each player, list the total number of 'Legendary' rarity items they have in their inventory, along with the titles of the respective games those items belong to."}, {"role": "assistant", "content": "SELECT pi.player_id, g.game_id, g.title, COUNT(*) AS legendary_item_count\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.in_game_items i ON pi.item_id = i.item_id\nJOIN gaming_technology.games g ON i.game_id = g.game_id\nWHERE i.rarity = 'Legendary'\nGROUP BY pi.player_id, g.game_id, g.title;"}, {"role": "user", "content": "Please modify the query to only include players who have more than 2 'Legendary' items per game."}, {"role": "assistant", "content": "SELECT pi.player_id, g.game_id, g.title, COUNT(*) AS legendary_item_count\nFROM gaming_technology.player_inventory pi\nJOIN gaming_technology.in_game_items i ON pi.item_id = i.item_id\nJOIN gaming_technology.games g ON i.game_id = g.game_id\nWHERE i.rarity = 'Legendary'\nGROUP BY pi.player_id, g.game_id, g.title\nHAVING COUNT(*) > 2;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.game_sessions ( session_id uuid PRIMARY KEY, player_id uuid, game_id uuid, server_id uuid, start_time timestamptz, end_time timestamptz, duration_seconds int, score int, session_data jsonb )\nCREATE TABLE gaming_technology.servers ( server_id.uuid, game_id.uuid, server_name.text, region.text, ip_address.text, port.integer, current_players.integer, max_players.integer, status.text, last_heartbeat.timestamptz )\nCREATE TABLE gaming_technology.player_achievements ( player_achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), player_id uuid NOT NULL, achievement_id uuid NOT NULL, unlocked_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (player_achievement_id), UNIQUE (player_id, achievement_id) )\nCREATE TABLE gaming_technology.in_game_items ( item_id uuid, game_id uuid, item_name text, item_type text, description text, rarity text, cost_currency text, cost_amount numeric, attributes jsonb )\n"}
{"conversations": [{"role": "user", "content": "For all NFT collections on the Ethereum blockchain, show me the collection name and the current floor price. Sort by floor price descending."}, {"role": "assistant", "content": "SELECT name, floor_price FROM nft_collections WHERE blockchain = 'Ethereum' ORDER BY CAST(floor_price AS FLOAT) DESC;"}, {"role": "user", "content": "Include also the collection symbol and the number of tokens in each collection."}, {"role": "assistant", "content": "SELECT name, symbol, floor_price, token_count FROM nft_collections WHERE blockchain = 'Ethereum' ORDER BY CAST(floor_price AS FLOAT) DESC;"}, {"role": "user", "content": "Can you also show the owner of each collection in the result?"}, {"role": "assistant", "content": "SELECT name, symbol, floor_price, token_count, owner FROM nft_collections WHERE blockchain = 'Ethereum' ORDER BY CAST(floor_price AS FLOAT) DESC;"}, {"role": "user", "content": "Now only include collections whose floor price is greater than 1 ETH."}, {"role": "assistant", "content": "SELECT name, symbol, floor_price, token_count, owner FROM nft_collections WHERE blockchain = 'Ethereum' AND CAST(floor_price AS FLOAT) > 1 AND floor_price_symbol = 'ETH' ORDER BY CAST(floor_price AS FLOAT) DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE token_metas ( block_timestamp timestamp(6) NOT NULL, block_number bigint NOT NULL, transaction_hash varchar NOT NULL, transaction_index bigint NOT NULL, from_address varchar NOT NULL, contract_address varchar NOT NULL, symbol varchar NOT NULL, total_supply varchar NOT NULL, name varchar NOT NULL, decimals bigint NOT NULL, is_erc20 integer NOT NULL, is_erc721 integer NOT NULL, is_erc1155 integer NOT NULL, is_proxy integer NOT NULL, extra_info varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE erc20_balances ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE nft_holder_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_metadata ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, token_id varchar NOT NULL, contract_name varchar NOT NULL, erc_type varchar NOT NULL, amount bigint NOT NULL, minter varchar NOT NULL, owner varchar NOT NULL, mint_block_number bigint NOT NULL, mint_time bigint NOT NULL, mint_transaction_hash varchar NOT NULL, mint_price varchar NOT NULL, token_uri varchar NOT NULL, metadata varchar NOT NULL, name varchar NOT NULL, image_uri varchar NOT NULL, traits varchar NOT NULL, updated_at bigint NOT NULL, status varchar NOT NULL, rarity_score real NOT NULL, rarity_rank integer NOT NULL, unique_attribute_count integer NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_prices ( uuid varchar(36) NOT NULL, blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )\nCREATE TABLE token_prices_latest ( blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )\nCREATE TABLE erc20_approval ( block_number bigint NOT NULL, block_timestamp timestamp(6) NOT NULL, transaction_index integer NOT NULL, transaction_hash varchar NOT NULL, log_index integer NOT NULL, contract_address varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_activities ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar NOT NULL, tick varchar NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(42) NOT NULL, to_address varchar(42) NOT NULL )\nCREATE TABLE mud_holesky_redstone ( address varchar NOT NULL, table_id varchar NOT NULL, key_bytes varchar NOT NULL, key0 varchar NOT NULL, key1 varchar NOT NULL, static_data varchar NOT NULL, encoded_lengths varchar NOT NULL, dynamic_data varchar NOT NULL, is_deleted boolean NOT NULL, block_number bigint NOT NULL, log_index bigint NOT NULL )\nCREATE TABLE token_balances_bitcoin ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar(255) NOT NULL, wallet_address varchar(42) NOT NULL, total_supply varchar NOT NULL, amount varchar NOT NULL )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(62) NOT NULL, to_address varchar(62) NOT NULL )\nCREATE TABLE token_info_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar(20) NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL, minted decimal(38,0) NOT NULL, holders decimal(38,0) NOT NULL, txs decimal(38,0) NOT NULL, updated_timestamp timestamp(3) NOT NULL, completed_timestamp timestamp(3) NOT NULL, id varchar(255) NOT NULL )\n"}
{"conversations": [{"role": "user", "content": "What is the count of customers for each state where the status is 'Active' and the created_at date is within the last 3 months?"}, {"role": "assistant", "content": "SELECT state, COUNT(*) as customer_count FROM financial_services.customers WHERE status = 'Active' AND created_at >= CURRENT_DATE - INTERVAL '3 months' GROUP BY 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 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": "Show me all active policies with coverage limits above $500,000, along with the customer names and agent names."}, {"role": "assistant", "content": "SELECT p.policy_id, p.customer_id, p.agent_id, p.coverage_limit, c.name AS customer_name, a.name AS agent_name FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id JOIN insurance.agents a ON p.agent_id = a.agent_id WHERE p.status = 'active' AND p.coverage_limit > 500000;"}, {"role": "user", "content": "Actually, I only want to see policies that started in the last year and have a deductible of $1000 or more."}, {"role": "assistant", "content": "SELECT p.policy_id, p.customer_id, p.agent_id, p.coverage_limit, p.deductible, c.name AS customer_name, a.name AS agent_name FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id JOIN insurance.agents a ON p.agent_id = a.agent_id WHERE p.status = 'active' AND p.coverage_limit > 500000 AND p.start_date >= DATE_SUB(CURRENT_DATE, INTERVAL 1 YEAR) AND p.deductible >= 1000;"}, {"role": "user", "content": "Now include the count of claims each of these policies has had."}, {"role": "assistant", "content": "SELECT p.policy_id, p.customer_id, p.agent_id, p.coverage_limit, p.deductible, c.name AS customer_name, a.name AS agent_name, COUNT(cl.claim_id) AS claim_count FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id JOIN insurance.agents a ON p.agent_id = a.agent_id LEFT JOIN insurance.claims cl ON p.policy_id = cl.policy_id WHERE p.status = 'active' AND p.coverage_limit > 500000 AND p.start_date >= DATE_SUB(CURRENT_DATE, INTERVAL 1 YEAR) AND p.deductible >= 1000 GROUP BY p.policy_id, p.customer_id, p.agent_id, p.coverage_limit, p.deductible, c.name, a.name;"}, {"role": "user", "content": "Finally, order the results by claim count in descending order and then by coverage limit in descending order."}, {"role": "assistant", "content": "SELECT p.policy_id, p.customer_id, p.agent_id, p.coverage_limit, p.deductible, c.name AS customer_name, a.name AS agent_name, COUNT(cl.claim_id) AS claim_count FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id JOIN insurance.agents a ON p.agent_id = a.agent_id LEFT JOIN insurance.claims cl ON p.policy_id = cl.policy_id WHERE p.status = 'active' AND p.coverage_limit > 500000 AND p.start_date >= DATE_SUB(CURRENT_DATE, INTERVAL 1 YEAR) AND p.deductible >= 1000 GROUP BY p.policy_id, p.customer_id, p.agent_id, p.coverage_limit, p.deductible, c.name, a.name ORDER BY claim_count DESC, p.coverage_limit 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 )\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.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": "Find all medical records where the treatment plan includes 'physical therapy' and the patient has an active primary insurance plan, showing the patient ID, record date, and insurance provider details."}, {"role": "assistant", "content": "SELECT mr.patient_id, mr.record_date, ip.insurance_provider, ip.plan_name, pi.policy_number FROM healthcare.medical_records mr JOIN healthcare.patients p ON mr.patient_id = p.patient_id JOIN healthcare.patient_insurance pi ON p.patient_id = pi.patient_id AND pi.is_primary = true JOIN healthcare.insurance_plans ip ON pi.plan_id = ip.plan_id WHERE mr.treatment_plan LIKE '%physical therapy%' AND (pi.expiration_date IS NULL OR pi.expiration_date > CURRENT_DATE);"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.patients ( patient_id text, first_name text, last_name text, date_of_birth date, gender text, address text, phone_number text, email text, emergency_contact_name text, emergency_contact_phone text, created_at timestamp, updated_at timestamp )\nCREATE TABLE healthcare.appointments ( appointment_id text, patient_id text, doctor_id text, appointment_time timestamp, duration_minutes integer, reason text, status text, location_id text, notes text, created_at timestamp )\nCREATE TABLE healthcare.medical_records ( record_id text PRIMARY KEY, patient_id text, appointment_id text, doctor_id text, record_date timestamp, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals text, created_at timestamp )\nCREATE TABLE healthcare.diagnoses ( diagnosis_id text PRIMARY KEY, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )\nCREATE TABLE healthcare.medications ( medication_id text, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )\nCREATE TABLE healthcare.insurance_plans (\n    plan_id character varying(64) NOT NULL, -- unique identifier for the insurance plan\n    plan_name character varying(200) NOT NULL, -- name of the insurance plan\n    insurance_provider character varying(100) NOT NULL, -- name of the insurance company\n    plan_type character varying(50), -- e.g., PPO, HMO, EPO\n    contact_phone character varying(20), -- provider contact number\n    website character varying(255), -- provider website\n    PRIMARY KEY (plan_id)\n)\nCREATE TABLE healthcare.patient_insurance ( patient_insurance_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, plan_id character varying(64) NOT NULL, policy_number character varying(100) NOT NULL, group_number character varying(100), subscriber_name character varying(200), effective_date date NOT NULL, expiration_date date, is_primary boolean NOT NULL DEFAULT true, PRIMARY KEY (patient_insurance_id), UNIQUE (patient_id, plan_id, policy_number) )\n"}
{"conversations": [{"role": "user", "content": "Can you show me each user's address and the date their wallet was created?"}, {"role": "assistant", "content": "SELECT user_id, address, created_at FROM trading_platform.wallets;"}, {"role": "user", "content": "Now, can you show only wallets created after '2024-01-01' and include the user_id and address?"}, {"role": "assistant", "content": "SELECT user_id, address, created_at FROM trading_platform.wallets WHERE created_at > '2024-01-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show me the deployer address and the count of contracts they have deployed on the 'mainnet' network, but only for deployers who have deployed more than 5 contracts on mainnet. Sort the results by the count in descending order."}, {"role": "assistant", "content": "SELECT deployer_address, COUNT(*) FROM web3.contracts WHERE network_id = 'mainnet' GROUP BY deployer_address HAVING COUNT(*) > 5 ORDER BY COUNT(*) DESC;"}], "system": "You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement. \n##Table Structure\nCREATE TABLE web3.contracts ( contract_id text PRIMARY KEY, address text, abi text, bytecode text, deployer_address text, deployed_at timestamp, network_id text, status text )\n"}
{"conversations": [{"role": "user", "content": "What are the top 5 tokens by 7-day price change percentage? Show token_symbol, token_name, narrative, and chain, ordered by price_change_percentage_7d descending."}, {"role": "assistant", "content": "```sql\nSELECT\n  token_symbol,\n  token_name,\n  narrative,\n  chain\nFROM token_basic_info\nORDER BY price_change_percentage_7d DESC\nLIMIT 5;\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 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\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) )\nCREATE TABLE smart_money_token_performance ( token_address text, token_symbol text, pnl numeric, net_flow numeric, avg_cost numeric, price numeric, realized_ratio numeric, roi numeric, chain text )\nCREATE TABLE smart_money_token_inflow ( token_address text, token_symbol text, token_amount numeric, usd_value numeric, avg_price numeric, type numeric, address_amount numeric, narrative text, chain text )\n"}
{"conversations": [{"role": "user", "content": "List all service orders for spa services with their guest names and total prices, ordered by total price in descending order."}, {"role": "assistant", "content": "SELECT g.first_name, g.last_name, so.order_id, so.total_price FROM hospitality_technology.service_orders so JOIN hospitality_technology.guests g ON so.guest_id = g.guest_id WHERE so.service_id LIKE 'SPA%' ORDER BY so.total_price DESC;"}, {"role": "user", "content": "Now, include only orders with a total price over $100 and show the property ID where the service was ordered."}, {"role": "assistant", "content": "SELECT g.first_name, g.last_name, so.order_id, so.total_price, r.property_id FROM hospitality_technology.service_orders so JOIN hospitality_technology.guests g ON so.guest_id = g.guest_id JOIN hospitality_technology.reservations r ON so.reservation_id = r.reservation_id WHERE so.service_id LIKE 'SPA%' AND so.total_price > 100 ORDER BY so.total_price DESC;"}, {"role": "user", "content": "The query is missing the service name. Can you include that as well?"}, {"role": "assistant", "content": "SELECT g.first_name, g.last_name, so.order_id, so.total_price, r.property_id, s.service_name FROM hospitality_technology.service_orders so JOIN hospitality_technology.guests g ON so.guest_id = g.guest_id JOIN hospitality_technology.reservations r ON so.reservation_id = r.reservation_id JOIN hospitality_technology.services s ON so.service_id = s.service_id WHERE so.service_id LIKE 'SPA%' AND so.total_price > 100 ORDER BY so.total_price DESC;"}, {"role": "user", "content": "Actually, I only need orders from properties in California, and order by property ID first, then by total price."}, {"role": "assistant", "content": "SELECT g.first_name, g.last_name, so.order_id, so.total_price, r.property_id, s.service_name FROM hospitality_technology.service_orders so JOIN hospitality_technology.guests g ON so.guest_id = g.guest_id JOIN hospitality_technology.reservations r ON so.reservation_id = r.reservation_id JOIN hospitality_technology.services s ON so.service_id = s.service_id JOIN hospitality_technology.properties p ON r.property_id = p.property_id WHERE so.service_id LIKE 'SPA%' AND so.total_price > 100 AND p.state_province = 'California' ORDER BY r.property_id, so.total_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.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 (\n    guest_id character varying(64) NOT NULL,  -- unique identifier for the guest profile\n    first_name character varying(100) NOT NULL, -- guest's first name\n    last_name character varying(100) NOT NULL, -- guest's last name\n    email character varying(255) UNIQUE, -- guest's email address (unique identifier?)\n    phone_number character varying(30), -- guest's phone number\n    date_of_birth date, -- guest's date of birth\n    address_line1 character varying(255), -- guest's home address\n    city character varying(100),\n    state_province character varying(100),\n    postal_code character varying(20),\n    country_code character varying(3),\n    preferences text, -- notes on guest preferences (e.g., allergies, room location)\n    loyalty_member_id character varying(64) UNIQUE, -- FK to loyalty_members table\n    communication_consent boolean DEFAULT true, -- consent for marketing communications\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 (guest_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.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 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 text, property_id text, reservation_id text, guest_id text, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source text, review_date timestamp, is_public boolean, staff_response text, response_staff_id text, response_date timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show me all asset types along with the count of distinct assets and the count of log actions for each type."}, {"role": "assistant", "content": "SELECT a.type, COUNT(DISTINCT a.asset_id) AS asset_count, COUNT(l.log_id) AS action_count FROM trading_platform.assets a LEFT JOIN trading_platform.logs l ON a.asset_id = l.details->>'asset_id' GROUP BY a.type ORDER BY 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": "Which chain has the highest total USD inflow from buy transactions (type=1), and how many distinct tokens were involved in that inflow?"}, {"role": "assistant", "content": "SELECT chain, SUM(usd_value) AS total_inflow, COUNT(DISTINCT token_symbol) AS distinct_tokens\nFROM smart_money_token_inflow\nWHERE type = 1\nGROUP BY chain\nORDER BY total_inflow DESC\nLIMIT 1;"}, {"role": "user", "content": "I also want to see the average price at which those tokens were bought for that chain."}, {"role": "assistant", "content": "WITH inflow AS (\n  SELECT chain, SUM(usd_value) AS total_inflow\n  FROM smart_money_token_inflow\n  WHERE type = 1\n  GROUP BY chain\n), top_chain AS (\n  SELECT chain FROM inflow ORDER BY total_inflow DESC LIMIT 1\n)\nSELECT i.chain, AVG(i.avg_price) AS avg_buy_price\nFROM smart_money_token_inflow i\nJOIN top_chain t ON i.chain = t.chain\nWHERE i.type = 1;"}, {"role": "user", "content": "Actually, filter to narratives where the total USD inflow is above 50000."}, {"role": "assistant", "content": "SELECT narrative, SUM(usd_value) AS total_inflow, COUNT(DISTINCT token_symbol) AS distinct_tokens\nFROM smart_money_token_inflow\nWHERE type = 1\nGROUP BY narrative\nHAVING SUM(usd_value) > 50000;"}, {"role": "user", "content": "Please order the results by average price descending and show the top 2 chains."}, {"role": "assistant", "content": "SELECT chain, SUM(usd_value) AS total_inflow, COUNT(DISTINCT token_symbol) AS distinct_tokens, AVG(avg_price) AS avg_buy_price\nFROM smart_money_token_inflow\nWHERE type = 1\nGROUP BY chain\nORDER BY avg_buy_price DESC\nLIMIT 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 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": "Find the top 5 ERC20 tokens by number of approval events in `erc20_approval`. Show `contract_address`, `symbol`, and `total_approvals`."}, {"role": "assistant", "content": "SELECT ea.contract_address,\n       tm.symbol,\n       COUNT(*) AS total_approvals\nFROM erc20_approval ea\nJOIN token_metas tm ON ea.contract_address = tm.contract_address\nWHERE tm.is_erc20 = 1\nGROUP BY ea.contract_address, tm.symbol\nORDER BY total_approvals DESC\nLIMIT 5;"}, {"role": "user", "content": "Also include `decimals` for each token."}, {"role": "assistant", "content": "SELECT ea.contract_address,\n       tm.symbol,\n       tm.decimals,\n       COUNT(*) AS total_approvals\nFROM erc20_approval ea\nJOIN token_metas tm ON ea.contract_address = tm.contract_address\nWHERE tm.is_erc20 = 1\nGROUP BY ea.contract_address, tm.symbol, tm.decimals\nORDER BY total_approvals DESC\nLIMIT 5;"}, {"role": "user", "content": "Only include tokens where `is_proxy = 0`."}, {"role": "assistant", "content": "SELECT ea.contract_address,\n       tm.symbol,\n       tm.decimals,\n       COUNT(*) AS total_approvals\nFROM erc20_approval ea\nJOIN token_metas tm ON ea.contract_address = tm.contract_address\nWHERE tm.is_erc20 = 1\n  AND tm.is_proxy = 0\nGROUP BY ea.contract_address, tm.symbol, tm.decimals\nORDER BY total_approvals DESC\nLIMIT 5;"}, {"role": "user", "content": "Now add the latest USD price for each token by joining `token_prices` using the most recent timestamp per address."}, {"role": "assistant", "content": "SELECT ea.contract_address,\n       tm.symbol,\n       tm.decimals,\n       COUNT(*) AS total_approvals,\n       tp.price AS latest_price\nFROM erc20_approval ea\nJOIN token_metas tm ON ea.contract_address = tm.contract_address\nLEFT JOIN token_prices tp\n  ON tp.address = tm.contract_address\n  AND tp.timestamp = (\n    SELECT MAX(tp2.timestamp)\n    FROM token_prices tp2\n    WHERE tp2.address = tm.contract_address\n  )\nWHERE tm.is_erc20 = 1\n  AND tm.is_proxy = 0\nGROUP BY ea.contract_address, tm.symbol, tm.decimals, tp.price\nORDER BY total_approvals 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 token_metas ( block_timestamp.timestamp, block_number.bigint, transaction_hash.text, transaction_index.bigint, from_address.text, contract_address.text, symbol.text, total_supply.text, name.text, decimals.bigint, is_erc20.integer, is_erc721.integer, is_erc1155.integer, is_proxy.integer, extra_info.text, pk.integer )\nCREATE TABLE erc1155_approval_for_all (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction\n    transaction_index integer NOT NULL, -- Index of the transaction within the block\n    transaction_hash varchar(66) NOT NULL, -- Transaction hash\n    log_index integer NOT NULL, -- Log index\n    contract_address varchar(42) NOT NULL  -- Event contract address\n)\nCREATE TABLE nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE sui_coins ( object_id varchar NOT NULL, status varchar NOT NULL, coin_type varchar NOT NULL, balance varchar NOT NULL, owner varchar NOT NULL )\nCREATE TABLE sui_coins_metadata (\n    object_id varchar NOT NULL, -- object id of the coin metadata object\n    coin_type varchar NOT NULL, -- coin type, eg. 0x...66::reap_token::REAP_TOKEN\n    status varchar NOT NULL, -- coin status, eg. exists, deleted\n    decimals bigint NOT NULL, -- decimals of the coin\n    description varchar NOT NULL, -- description of the coin\n    icon_url varchar NOT NULL, -- icon url of the coin\n    symbol varchar NOT NULL, -- symbol of the coin\n    name varchar NOT NULL  -- name of the coin\n)\nCREATE TABLE nft_metadata ( blockchain text, contract_address text, token_id text, contract_name text, erc_type text, amount bigint, minter text, owner text, mint_block_number bigint, mint_time bigint, mint_transaction_hash text, mint_price text, token_uri text, metadata text, name text, image_uri text, traits text, updated_at bigint, status text, rarity_score real, rarity_rank integer, unique_attribute_count integer, pk integer )\nCREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint NOT NULL, block_timestamp timestamp(6) NOT NULL, transaction_index integer NOT NULL, transaction_hash varchar NOT NULL, log_index integer NOT NULL, contract_address varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_balances ( block_number.bigint, block_timestamp.timestamp, tick.text, wallet_address.text, total_supply.decimal, amount.decimal )\nCREATE TABLE token_info (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    tick varchar NOT NULL, -- Token tick\n    max_supply decimal(38,0) NOT NULL, -- Max supply\n    lim decimal(38,0) NOT NULL, -- Limit of each mint\n    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint\n    dec integer NOT NULL, -- Decimal for minimum divie\n    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)\n)\nCREATE TABLE mud_holesky_redstone (\n    address varchar NOT NULL, -- address fields for the functionType  in contract\n    table_id varchar NOT NULL, -- table_id fields for the functionType  in contract\n    key_bytes varchar NOT NULL, -- key_bytes fields for the functionType  in contract\n    key0 varchar NOT NULL, -- key0 fields for the functionType  in contract\n    key1 varchar NOT NULL, -- key1 fields for the functionType  in contract\n    static_data varchar NOT NULL, -- static_data fields for the functionType  in contract\n    encoded_lengths varchar NOT NULL, -- encoded_lengths fields for the functionType  in contract\n    dynamic_data varchar NOT NULL, -- dynamic_data fields for the functionType  in contract\n    is_deleted boolean NOT NULL, -- is_deleted fields for the functionType  in contract\n    block_number bigint NOT NULL, -- Block number uniquely identifying the block\n    log_index bigint NOT NULL  -- Index of the log within the transaction\n)\nCREATE TABLE token_info_bitcoin ( block_timestamp.timestamp, block_number.bigint, tx_index.integer, tx_hash.text, tick.text, max_supply.decimal, lim.decimal, wlim.decimal, dec.integer, creator.text )\nCREATE TABLE token_activities_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, log_index integer, type text, tick text, id text, amt decimal, from_address text, to_address text )\nCREATE TABLE token_balances_avalanche ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )\n"}
{"conversations": [{"role": "user", "content": "What is the fuel consumption rate of train number T1234?"}, {"role": "assistant", "content": "I'm sorry, but I don't have information on the fuel consumption rate of train number T1234. The data available in the system only includes details such as train ID, model, manufacturer, year manufactured, capacity, status, and maintenance dates."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.trains ( train_id character varying(64) NOT NULL, train_number character varying(32) NOT NULL, model character varying(128), manufacturer character varying(128), year_manufactured integer, capacity integer NOT NULL, status character varying(32) NOT NULL DEFAULT 'Active', last_maintenance_date date, next_maintenance_date date, PRIMARY KEY (train_id), UNIQUE (train_number) )\n"}
{"conversations": [{"role": "user", "content": "What is the average age of verified citizens as of today?"}, {"role": "assistant", "content": "SELECT AVG(EXTRACT(YEAR FROM AGE(NOW(), date_of_birth))) AS average_age_verified\nFROM government_services.citizens\nWHERE is_verified = TRUE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id text 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.notifications ( notification_id text PRIMARY KEY, citizen_id text, application_id text, message_subject text, message_body text, channel text, sent_at timestamp, status text, related_entity_type text, related_entity_id text )\n"}
{"conversations": [{"role": "user", "content": "Show me all active policies for customers who live in California, along with their total premium payments made so far."}, {"role": "assistant", "content": "SELECT p.policy_id, p.policy_number, c.first_name, c.last_name, p.premium_amount, SUM(pp.amount_paid) AS total_payments_made FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id LEFT JOIN insurance.premium_payments pp ON p.policy_id = pp.policy_id WHERE p.status = 'Active' AND c.state = 'California' GROUP BY p.policy_id, p.policy_number, c.first_name, c.last_name, p.premium_amount;"}, {"role": "user", "content": "I also want to see how many claims each of these policies has had."}, {"role": "assistant", "content": "SELECT p.policy_id, p.policy_number, c.first_name, c.last_name, p.premium_amount, SUM(pp.amount_paid) AS total_payments_made, COUNT(cl.claim_id) AS claim_count FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id LEFT JOIN insurance.premium_payments pp ON p.policy_id = pp.policy_id LEFT JOIN insurance.claims cl ON p.policy_id = cl.policy_id WHERE p.status = 'Active' AND c.state = 'California' GROUP BY p.policy_id, p.policy_number, c.first_name, c.last_name, p.premium_amount;"}, {"role": "user", "content": "Actually, I only want to see policies that have at least one claim."}, {"role": "assistant", "content": "SELECT p.policy_id, p.policy_number, c.first_name, c.last_name, p.premium_amount, SUM(pp.amount_paid) AS total_payments_made, COUNT(cl.claim_id) AS claim_count FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id LEFT JOIN insurance.premium_payments pp ON p.policy_id = pp.policy_id JOIN insurance.claims cl ON p.policy_id = cl.policy_id WHERE p.status = 'Active' AND c.state = 'California' GROUP BY p.policy_id, p.policy_number, c.first_name, c.last_name, p.premium_amount HAVING COUNT(cl.claim_id) > 0;"}, {"role": "user", "content": "Now show me the average settlement amount for these policies' claims."}, {"role": "assistant", "content": "SELECT p.policy_id, p.policy_number, c.first_name, c.last_name, p.premium_amount, SUM(pp.amount_paid) AS total_payments_made, COUNT(cl.claim_id) AS claim_count, AVG(cl.settlement_amount) AS avg_settlement FROM insurance.policies p JOIN insurance.customers c ON p.customer_id = c.customer_id LEFT JOIN insurance.premium_payments pp ON p.policy_id = pp.policy_id JOIN insurance.claims cl ON p.policy_id = cl.policy_id WHERE p.status = 'Active' AND c.state = 'California' GROUP BY p.policy_id, p.policy_number, c.first_name, c.last_name, p.premium_amount HAVING COUNT(cl.claim_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 insurance.customers (\n    customer_id character varying(64) NOT NULL,  -- unique identifier for the customer\n    first_name character varying(100) NOT NULL, -- customer's first name\n    last_name character varying(100) NOT NULL, -- customer's last name\n    date_of_birth date NOT NULL, -- customer's date of birth\n    ssn_hash character varying(128), -- Hashed social security number (or national ID)\n    address_line1 character varying(255) NOT NULL,\n    address_line2 character varying(255),\n    city character varying(100) NOT NULL,\n    state character varying(50) NOT NULL,\n    zip_code character varying(20) NOT NULL,\n    country character varying(50) NOT NULL DEFAULT 'USA',\n    phone_number character varying(30),\n    email character varying(128) UNIQUE, -- unique email address\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the customer record was created\n    updated_at timestamp, -- when the customer record was last updated\n    status character varying(20) NOT NULL DEFAULT 'Active', -- e.g., Active, Inactive, Prospect\n    PRIMARY KEY (customer_id)\n)\nCREATE TABLE insurance.policies (\n    policy_id character varying(64) NOT NULL, -- unique identifier for the policy\n    customer_id character varying(64) NOT NULL, -- identifier for the policyholder (FK to customers)\n    product_id character varying(64) NOT NULL, -- identifier for the insurance product (FK to insurance_products)\n    agent_id character varying(64), -- identifier for the agent who sold the policy (FK to agents)\n    policy_number character varying(100) NOT NULL UNIQUE, -- customer-facing policy number\n    start_date date NOT NULL, -- date the policy coverage begins\n    end_date date NOT NULL, -- date the policy coverage ends\n    premium_amount numeric(12, 2) NOT NULL, -- total premium for the policy term\n    coverage_limit numeric(15, 2) NOT NULL, -- maximum amount covered\n    deductible numeric(10, 2) NOT NULL, -- amount customer pays before coverage kicks in\n    status character varying(30) NOT NULL, -- e.g., Active, Expired, Cancelled, Pending\n    issued_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the policy was issued\n    cancellation_date date,\n    cancellation_reason text,\n    PRIMARY KEY (policy_id)\n)\nCREATE TABLE insurance.claims (\n    claim_id character varying(64) NOT NULL, -- unique identifier for the claim\n    policy_id character varying(64) NOT NULL, -- identifier of the policy under which the claim is made (FK to policies)\n    customer_id character varying(64) NOT NULL, -- identifier of the customer making the claim (FK to customers)\n    incident_date timestamp NOT NULL, -- date and time of the incident leading to the claim\n    reported_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the claim was reported\n    description text NOT NULL, -- detailed description of the incident and claim\n    estimated_loss numeric(15, 2), -- initial estimated cost of the loss\n    status character varying(30) NOT NULL, -- e.g., Filed, Processing, Under Review, Approved, Denied, Settled\n    settlement_amount numeric(15, 2), -- final amount paid out\n    settlement_date date,\n    claim_handler_id character varying(64), -- identifier for the employee handling the claim (FK to employees/adjusters)\n    police_report_number character varying(100),\n    PRIMARY KEY (claim_id)\n)\nCREATE TABLE insurance.premium_payments (\n    payment_id character varying(64) NOT NULL, -- unique identifier for the payment\n    policy_id character varying(64) NOT NULL, -- identifier of the policy the payment is for (FK to policies)\n    customer_id character varying(64) NOT NULL, -- identifier of the customer making the payment (FK to customers)\n    payment_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the payment was received\n    amount_paid numeric(12, 2) NOT NULL, -- amount of the payment\n    payment_method character varying(50), -- e.g., Credit Card, Bank Transfer, Check\n    transaction_reference character varying(128) UNIQUE, -- reference from payment processor\n    due_date date, -- due date for this payment installment\n    payment_period_start date, -- start date of the period this payment covers\n    payment_period_end date, -- end date of the period this payment covers\n    status character varying(30) NOT NULL DEFAULT 'Completed', -- e.g., Completed, Pending, Failed, Refunded\n    PRIMARY KEY (payment_id)\n)\nCREATE TABLE insurance.claim_documents (\n    document_id character varying(64) NOT NULL, -- unique identifier for the document\n    claim_id character varying(64) NOT NULL, -- identifier of the claim this document relates to (FK to claims)\n    document_type character varying(50) NOT NULL, -- e.g., Police Report, Photo, Invoice, Medical Bill\n    file_name character varying(255) NOT NULL, -- original name of the uploaded file\n    file_path character varying(512) NOT NULL, -- storage path (e.g., S3 URL, network path)\n    file_size_bytes integer, -- size of the file in bytes\n    mime_type character varying(100), -- MIME type of the file (e.g., 'image/jpeg', 'application/pdf')\n    uploaded_by character varying(64), -- identifier of the user/system who uploaded (FK to users/customers)\n    uploaded_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- time of upload\n    description text, -- optional description of the document\n    PRIMARY KEY (document_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all patients who have insurance plans with group numbers, showing their patient IDs and the count of such plans per patient."}, {"role": "assistant", "content": "SELECT patient_id, COUNT(*) AS plan_count FROM healthcare.patient_insurance WHERE group_number IS NOT NULL GROUP BY patient_id;"}, {"role": "user", "content": "Actually, I only need patients who have more than 2 such plans."}, {"role": "assistant", "content": "SELECT patient_id, COUNT(*) AS plan_count FROM healthcare.patient_insurance WHERE group_number IS NOT NULL GROUP BY patient_id HAVING COUNT(*) > 2;"}, {"role": "user", "content": "Can you also include the earliest effective date among these plans for each patient?"}, {"role": "assistant", "content": "SELECT patient_id, COUNT(*) AS plan_count, MIN(effective_date) AS earliest_effective_date FROM healthcare.patient_insurance WHERE group_number IS NOT NULL GROUP BY patient_id HAVING COUNT(*) > 2;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.patient_insurance (\n    patient_insurance_id character varying(64) NOT NULL, -- unique identifier for this patient-plan link\n    patient_id character varying(64) NOT NULL, -- FK to patients table\n    plan_id character varying(64) NOT NULL, -- FK to insurance_plans table\n    policy_number character varying(100) NOT NULL, -- patient's policy number\n    group_number character varying(100), -- group number, if applicable\n    subscriber_name character varying(200), -- name of the primary policy holder\n    effective_date date NOT NULL, -- date the coverage begins\n    expiration_date date, -- date the coverage ends (if known)\n    is_primary boolean NOT NULL DEFAULT true, -- indicates if this is the primary insurance\n    PRIMARY KEY (patient_insurance_id),\n    UNIQUE (patient_id, plan_id, policy_number) -- ensure a patient doesn't have the same policy twice\n)\n"}
{"conversations": [{"role": "user", "content": "Give me the total number of doctors for each specialty."}, {"role": "assistant", "content": "SELECT specialty, COUNT(*) AS doctor_count\nFROM healthcare.doctors\nGROUP BY specialty;"}], "system": "You are an SQL statement expert. Given the table structure 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 )\n"}
{"conversations": [{"role": "user", "content": "List all ERC20 tokens where the price is greater than $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.address WHERE tpl.price > 10 AND tm.is_erc20 = 1;"}, {"role": "user", "content": "I think there's an error in your query - it should be 'tpl.price > 10' not 'tpl.price > 10'. Also, can you add the current price to the results?"}, {"role": "assistant", "content": "SELECT tm.name, tm.symbol, tm.contract_address, tpl.price FROM token_metas tm JOIN token_prices_latest tpl ON tm.contract_address = tpl.address WHERE tpl.price > 10 AND tm.is_erc20 = 1;"}, {"role": "user", "content": "Now sort these results by price in descending order and limit to the top 10."}, {"role": "assistant", "content": "SELECT tm.name, tm.symbol, tm.contract_address, tpl.price FROM token_metas tm JOIN token_prices_latest tpl ON tm.contract_address = tpl.address WHERE tpl.price > 10 AND tm.is_erc20 = 1 ORDER BY tpl.price DESC LIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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, block_timestamp timestamp, transaction_index integer, transaction_hash varchar, log_index integer, contract_address varchar )\nCREATE TABLE erc20_balances ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk varchar )\nCREATE TABLE nft_holders ( block_number bigint, contract_address varchar, wallet_address varchar, token_id varchar, contract_type varchar, amount varchar, pk varchar )\nCREATE TABLE nft_holder_historical ( block_number bigint, contract_address varchar, wallet_address varchar, token_id varchar, contract_type varchar, amount varchar, pk integer )\nCREATE TABLE sui_coins_metadata ( object_id varchar, coin_type varchar, status varchar, decimals bigint, description varchar, icon_url varchar, symbol varchar, name varchar )\nCREATE TABLE nft_metadata ( blockchain varchar, contract_address varchar, token_id varchar, contract_name varchar, erc_type varchar, amount bigint, minter varchar, owner varchar, mint_block_number bigint, mint_time bigint, mint_transaction_hash varchar, mint_price varchar, token_uri varchar, metadata varchar, name varchar, image_uri varchar, traits varchar, updated_at bigint, status varchar, rarity_score real, rarity_rank integer, unique_attribute_count integer, pk integer )\nCREATE TABLE nft_collections ( blockchain varchar, contract_address varchar, name varchar, symbol varchar, deploy_block_number bigint, deploy_block_time bigint, erc_type varchar, owner varchar, traits varchar, description varchar, slug varchar, media_info varchar, image_url varchar, banner_image_url varchar, updated_at bigint, banner varchar, token_count bigint, floor_price varchar, floor_price_symbol varchar, floor_price_contract varchar, pk integer )\nCREATE TABLE token_prices ( uuid varchar, blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE token_prices_latest ( blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash varchar, log_index integer, contract_address varchar, pk integer )\nCREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )\nCREATE TABLE token_info ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash varchar, tick varchar, max_supply decimal, lim decimal, wlim decimal, dec integer, creator varchar )\nCREATE TABLE token_activities ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash varchar, log_index integer, type varchar, tick varchar, id varchar, amt decimal, from_address varchar, to_address varchar )\nCREATE TABLE mud_holesky_redstone ( address varchar, table_id varchar, key_bytes varchar, key0 varchar, key1 varchar, static_data varchar, encoded_lengths varchar, dynamic_data varchar, is_deleted boolean, block_number bigint, log_index bigint )\nCREATE TABLE token_balances_bitcoin ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply varchar, amount varchar )\nCREATE TABLE token_info_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash varchar, tick varchar, max_supply decimal, lim decimal, wlim decimal, dec integer, creator varchar )\nCREATE TABLE token_activities_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_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 ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )\nCREATE TABLE token_info_avalanche ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash 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": "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 me the top 5 NFT collections with the highest floor price on Ethereum, along with their names and contract addresses, but only include collections with more than 5000 tokens."}, {"role": "assistant", "content": "SELECT nc.name, nc.contract_address, nc.floor_price FROM nft_collections nc WHERE nc.blockchain = 'Ethereum' AND nc.token_count > 5000 ORDER BY CAST(nc.floor_price AS decimal) DESC LIMIT 5;"}, {"role": "user", "content": "Can you join this with the nft_metadata table to include the average rarity score for these collections?"}, {"role": "assistant", "content": "SELECT nc.name, nc.contract_address, nc.floor_price, AVG(nm.rarity_score) as avg_rarity_score FROM nft_collections nc JOIN nft_metadata nm ON nc.contract_address = nm.contract_address WHERE nc.blockchain = 'Ethereum' AND nc.token_count > 5000 GROUP BY nc.name, nc.contract_address, nc.floor_price ORDER BY CAST(nc.floor_price AS decimal) DESC LIMIT 5;"}, {"role": "user", "content": "Now filter these results to only show collections with an average rarity score above 75."}, {"role": "assistant", "content": "SELECT nc.name, nc.contract_address, nc.floor_price, AVG(nm.rarity_score) as avg_rarity_score FROM nft_collections nc JOIN nft_metadata nm ON nc.contract_address = nm.contract_address WHERE nc.blockchain = 'Ethereum' AND nc.token_count > 5000 GROUP BY nc.name, nc.contract_address, nc.floor_price HAVING AVG(nm.rarity_score) > 75 ORDER BY CAST(nc.floor_price 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_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 )\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": "Can you help me retrieve the details of all bookings for a specific route with route_id 'RT789', including the passenger names and the scheduled departure times?"}, {"role": "assistant", "content": "SELECT b.booking_id, p.first_name, p.last_name, s.departure_datetime, b.status, b.total_price\nFROM train_station_management.bookings b\nJOIN train_station_management.passengers p ON b.passenger_id = p.passenger_id\nJOIN train_station_management.schedules s ON b.schedule_id = s.schedule_id\nWHERE s.route_id = 'RT789';"}, {"role": "user", "content": "Can you modify the query to include only bookings with a status of 'Pending'?"}, {"role": "assistant", "content": "SELECT b.booking_id, p.first_name, p.last_name, s.departure_datetime, b.status, b.total_price\nFROM train_station_management.bookings b\nJOIN train_station_management.passengers p ON b.passenger_id = p.passenger_id\nJOIN train_station_management.schedules s ON b.schedule_id = s.schedule_id\nWHERE s.route_id = 'RT789' AND b.status = 'Pending';"}, {"role": "user", "content": "Can you also add the route name and origin station ID to the results?"}, {"role": "assistant", "content": "SELECT b.booking_id, p.first_name, p.last_name, s.departure_datetime, b.status, b.total_price, r.route_name, r.origin_station_id\nFROM train_station_management.bookings b\nJOIN train_station_management.passengers p ON b.passenger_id = p.passenger_id\nJOIN train_station_management.schedules s ON b.schedule_id = s.schedule_id\nJOIN train_station_management.routes r ON s.route_id = r.route_id\nWHERE s.route_id = 'RT789' AND b.status = 'Pending';"}, {"role": "user", "content": "Can you sort the results by departure datetime in descending order?"}, {"role": "assistant", "content": "SELECT b.booking_id, p.first_name, p.last_name, s.departure_datetime, b.status, b.total_price, r.route_name, r.origin_station_id\nFROM train_station_management.bookings b\nJOIN train_station_management.passengers p ON b.passenger_id = p.passenger_id\nJOIN train_station_management.schedules s ON b.schedule_id = s.schedule_id\nJOIN train_station_management.routes r ON s.route_id = r.route_id\nWHERE s.route_id = 'RT789' AND b.status = 'Pending'\nORDER BY s.departure_datetime 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 train_station_management.train_cars (\n    car_id character varying(64) NOT NULL, -- Unique identifier for the train car\n    train_id character varying(64) NOT NULL, -- Foreign key referencing trains\n    car_number character varying(10) NOT NULL, -- Identifier of the car within the train set\n    car_type character varying(64) NOT NULL, -- e.g., Locomotive, Passenger, Sleeper, Dining, Baggage\n    class character varying(32), -- e.g., First, Business, Economy (null for non-passenger cars)\n    capacity integer, -- Passenger capacity of this specific car (null for non-passenger cars)\n    features text, -- Comma-separated list of features (e.g., 'WiFi', 'Power Outlet', 'Accessible Restroom')\n    PRIMARY KEY (car_id),\n    FOREIGN KEY (train_id) REFERENCES train_station_management.trains(train_id)\n)\nCREATE TABLE train_station_management.routes (\n    route_id character varying(64) NOT NULL, -- Unique identifier for the route\n    route_name character varying(128) NOT NULL, -- Name of the route (e.g., 'Northeast Corridor')\n    description text, -- Description of the route\n    origin_station_id character varying(64) NOT NULL, -- Starting station\n    destination_station_id character varying(64) NOT NULL, -- Final station\n    is_active boolean NOT NULL DEFAULT true, -- Is the route currently operational?\n    PRIMARY KEY (route_id),\n    FOREIGN KEY (origin_station_id) REFERENCES train_station_management.stations(station_id),\n    FOREIGN KEY (destination_station_id) REFERENCES train_station_management.stations(station_id)\n)\nCREATE TABLE train_station_management.route_stations (\n    route_station_id character varying(64) NOT NULL, -- Unique ID for this route-station link\n    route_id character varying(64) NOT NULL, -- Foreign key referencing routes\n    station_id character varying(64) NOT NULL, -- Foreign key referencing stations\n    sequence_order integer NOT NULL, -- Order of the station in the route (1 for origin, 2, 3...)\n    distance_from_previous_km numeric(10, 2), -- Distance from the previous station in the sequence\n    typical_stop_duration_minutes integer, -- Typical dwell time at this station\n    PRIMARY KEY (route_station_id),\n    UNIQUE (route_id, station_id),\n    UNIQUE (route_id, sequence_order),\n    FOREIGN KEY (route_id) REFERENCES train_station_management.routes(route_id),\n    FOREIGN KEY (station_id) REFERENCES train_station_management.stations(station_id)\n)\nCREATE TABLE train_station_management.schedules (\n    schedule_id character varying(64) NOT NULL, -- Unique identifier for a specific scheduled trip\n    train_id character varying(64) NOT NULL, -- Foreign key referencing the train used\n    route_id character varying(64) NOT NULL, -- Foreign key referencing the route taken\n    departure_datetime timestamp with time zone NOT NULL, -- Scheduled departure time from origin station\n    arrival_datetime timestamp with time zone NOT NULL, -- Scheduled arrival time at destination station\n    status character varying(32) NOT NULL DEFAULT 'Scheduled', -- e.g., Scheduled, On Time, Delayed, Cancelled, Arrived\n    notes text, -- Any notes regarding this specific trip (e.g., reason for delay)\n    PRIMARY KEY (schedule_id),\n    FOREIGN KEY (train_id) REFERENCES train_station_management.trains(train_id),\n    FOREIGN KEY (route_id) REFERENCES train_station_management.routes(route_id)\n)\nCREATE TABLE train_station_management.passengers (\n    passenger_id character varying(64) NOT NULL, -- Unique identifier for the passenger\n    first_name character varying(100) NOT NULL, -- Passenger's first name\n    last_name character varying(100) NOT NULL, -- Passenger's last name\n    email character varying(128) UNIQUE, -- Passenger's email address\n    phone_number character varying(32) UNIQUE, -- Passenger's phone number\n    date_of_birth date, -- Passenger's date of birth\n    loyalty_program_id character varying(64), -- ID for loyalty program, if applicable\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- When the passenger record was created\n    PRIMARY KEY (passenger_id)\n)\nCREATE TABLE train_station_management.bookings (\n    booking_id character varying(64) NOT NULL, -- Unique identifier for the booking\n    passenger_id character varying(64) NOT NULL, -- Foreign key referencing the passenger\n    schedule_id character varying(64) NOT NULL, -- Foreign key referencing the scheduled trip\n    booking_datetime timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- When the booking was made\n    status character varying(32) NOT NULL DEFAULT 'Confirmed', -- e.g., Confirmed, Cancelled, Pending\n    total_price numeric(12, 2) NOT NULL, -- Total price for all tickets in this booking\n    currency_code character varying(3) NOT NULL DEFAULT 'USD', -- Currency of the price\n    special_requests text, -- Any special requests (e.g., wheelchair assistance)\n    PRIMARY KEY (booking_id),\n    FOREIGN KEY (passenger_id) REFERENCES train_station_management.passengers(passenger_id),\n    FOREIGN KEY (schedule_id) REFERENCES train_station_management.schedules(schedule_id)\n)\nCREATE TABLE train_station_management.staff (\n    staff_id character varying(64) NOT NULL, -- Unique identifier for the staff member\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    role character varying(64) NOT NULL, -- e.g., Station Master, Ticket Agent, Conductor, Engineer, Maintenance Crew\n    primary_station_id character varying(64), -- Base station for the staff member (nullable for mobile staff)\n    employee_number character varying(32) UNIQUE NOT NULL, -- Unique employee identifier\n    hire_date date NOT NULL,\n    contact_email character varying(128) UNIQUE,\n    contact_phone character varying(32),\n    is_active boolean NOT NULL DEFAULT true, -- Is the staff member currently employed?\n    PRIMARY KEY (staff_id),\n    FOREIGN KEY (primary_station_id) REFERENCES train_station_management.stations(station_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all maintenance logs for vehicles that had 'Oil Change' service in the last 3 months, showing vehicle ID, service date, and cost."}, {"role": "assistant", "content": "SELECT vehicle_id, service_date, cost FROM transportation.maintenance_logs WHERE service_type = 'Oil Change' AND service_date >= CURRENT_DATE - INTERVAL '3 months';"}, {"role": "user", "content": "Can you include the mechanic name and show only services that cost more than $100?"}, {"role": "assistant", "content": "SELECT vehicle_id, service_date, cost, mechanic_name FROM transportation.maintenance_logs WHERE service_type = 'Oil Change' AND service_date >= CURRENT_DATE - INTERVAL '3 months' AND cost > 100;"}, {"role": "user", "content": "Actually, I need to see the vehicle make and model as well. Can you include that information?"}, {"role": "assistant", "content": "Sorry, I can't include vehicle make and model as those fields aren't present in the provided table schemas. The maintenance_logs table only contains vehicle_id but not make/model information."}, {"role": "user", "content": "Then just add the odometer reading to the previous query and order by the most recent services first."}, {"role": "assistant", "content": "SELECT vehicle_id, service_date, cost, mechanic_name, odometer_reading FROM transportation.maintenance_logs WHERE service_type = 'Oil Change' AND service_date >= CURRENT_DATE - INTERVAL '3 months' AND cost > 100 ORDER BY service_date DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.drivers ( driver_id text, employee_id text, first_name text, last_name text, license_number text, license_expiry_date date, contact_number text, email text, hire_date date, status text )\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 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 )\n"}
{"conversations": [{"role": "user", "content": "What is the detailed repair history for train number T5678?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide the detailed repair history for train number T5678 as this information is not available in the current database table. The table only includes basic information such as train ID, model, manufacturer, capacity, status, and maintenance dates. For repair history, you may need to consult a different database or 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.trains ( train_id text, train_number text, model text, manufacturer text, year_manufactured integer, capacity integer, status text, last_maintenance_date date, next_maintenance_date date )\n"}
{"conversations": [{"role": "user", "content": "How many diagnoses does each status have grouped by is_chronic flag?"}, {"role": "assistant", "content": "SELECT is_chronic, status, COUNT(*) AS count FROM healthcare.diagnoses GROUP BY is_chronic, status;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.diagnoses ( diagnosis_id text, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )\n"}
{"conversations": [{"role": "user", "content": "Show me a list of all doctors who have made at least one diagnosis along with the total number of diagnoses they have made."}, {"role": "assistant", "content": "SELECT d.doctor_id, d.first_name, d.last_name, COUNT(di.diagnosis_id) AS diagnosis_count\nFROM healthcare.doctors d\nJOIN healthcare.diagnoses di ON d.doctor_id = di.doctor_id\nGROUP BY d.doctor_id, d.first_name, d.last_name\nHAVING COUNT(di.diagnosis_id) > 0;"}, {"role": "user", "content": "Now, limit the list to doctors with fewer than 10 diagnoses and order them by diagnosis_count ascending."}, {"role": "assistant", "content": "SELECT d.doctor_id, d.first_name, d.last_name, COUNT(di.diagnosis_id) AS diagnosis_count\nFROM healthcare.doctors d\nJOIN healthcare.diagnoses di ON d.doctor_id = di.doctor_id\nGROUP BY d.doctor_id, d.first_name, d.last_name\nHAVING COUNT(di.diagnosis_id) > 0 AND COUNT(di.diagnosis_id) < 10\nORDER BY diagnosis_count 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.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.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 (\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 ( 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 (\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 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": "Count the total number of cases that are currently marked as 'Open'."}, {"role": "assistant", "content": "SELECT COUNT(*) FROM cases WHERE 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.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 (\n    entry_id character varying(64) NOT NULL,  -- unique identifier for the time entry\n    case_id character varying(64) NOT NULL, -- FK to cases table\n    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table (who performed the work)\n    date_worked date NOT NULL, -- date the work was performed\n    hours_spent numeric(5, 2) NOT NULL CHECK (hours_spent > 0), -- duration of work in hours (e.g., 1.5 for 1h 30m)\n    billing_rate numeric(10, 2) NOT NULL, -- hourly rate applied for this entry\n    description text NOT NULL, -- detailed description of the work performed\n    is_billable boolean DEFAULT true, -- whether this time entry is billable to the client\n    is_billed boolean DEFAULT false, -- whether this entry has been included in an invoice\n    invoice_id character varying(64), -- FK to invoices table (once billed)\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the entry was recorded\n    PRIMARY KEY (entry_id)\n)\nCREATE TABLE legal_services.appointments (\n    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment\n    client_id character varying(64) NOT NULL, -- FK to clients table\n    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table\n    case_id character varying(64), -- FK to cases table (optional, if related to a specific case)\n    start_time timestamp NOT NULL, -- scheduled start date and time\n    end_time timestamp NOT NULL, -- scheduled end date and time\n    location text, -- location of the meeting (address or virtual link)\n    subject character varying(255), -- subject or purpose of the appointment\n    notes text, -- additional notes for the appointment\n    status character varying(50) NOT NULL, -- e.g., Scheduled, Completed, Canceled, Rescheduled\n    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,\n    PRIMARY KEY (appointment_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Find all chronic diagnoses made by Cardiology doctors in the last year, including patient ID, diagnosis description, and doctor's full name."}, {"role": "assistant", "content": "SELECT di.patient_id, di.description, d.first_name || ' ' || d.last_name AS doctor_name, di.diagnosis_date FROM healthcare.diagnoses di JOIN healthcare.doctors d ON di.doctor_id = d.doctor_id WHERE di.is_chronic = true AND d.specialty = 'Cardiology' AND di.diagnosis_date >= CURRENT_DATE - INTERVAL '1 year' ORDER BY di.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.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 ( 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.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) )\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": "Find the total transfer volume for each Avalanche token over the past 7 days and include the token's creator."}, {"role": "assistant", "content": "SELECT a.tick,\n       i.creator,\n       SUM(a.amt) AS total_volume\nFROM token_activities_avalanche a\nJOIN token_info_avalanche i\n  ON a.tick = i.tick\nWHERE a.block_timestamp >= NOW() - INTERVAL '7 days'\nGROUP BY a.tick, i.creator;"}, {"role": "user", "content": "Only include tokens with total_volume > 10000 and sort by total_volume descending."}, {"role": "assistant", "content": "SELECT a.tick,\n       i.creator,\n       SUM(a.amt) AS total_volume\nFROM token_activities_avalanche a\nJOIN token_info_avalanche i\n  ON a.tick = i.tick\nWHERE a.block_timestamp >= NOW() - INTERVAL '7 days'\nGROUP BY a.tick, i.creator\nHAVING SUM(a.amt) > 10000\nORDER BY total_volume DESC;"}, {"role": "user", "content": "Limit the results to the top 5 tokens."}, {"role": "assistant", "content": "SELECT a.tick,\n       i.creator,\n       SUM(a.amt) AS total_volume\nFROM token_activities_avalanche a\nJOIN token_info_avalanche i\n  ON a.tick = i.tick\nWHERE a.block_timestamp >= NOW() - INTERVAL '7 days'\nGROUP BY a.tick, i.creator\nHAVING SUM(a.amt) > 10000\nORDER BY total_volume 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 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_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_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_info_bitcoin ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar(255) NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL )\nCREATE TABLE token_activities_avalanche ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(42) NOT NULL, to_address varchar(42) NOT NULL )\nCREATE TABLE token_info_avalanche ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, tick text, max_supply decimal, lim decimal, wlim decimal, dec integer, creator text, minted decimal, holders decimal, txs decimal, updated_timestamp timestamp, completed_timestamp timestamp, id text )\n"}
{"conversations": [{"role": "user", "content": "List all patients who have active primary insurance plans with expiration dates within the next 60 days, including their policy numbers and subscriber names."}, {"role": "assistant", "content": "SELECT pi.patient_id, pi.policy_number, pi.subscriber_name FROM healthcare.patient_insurance pi WHERE pi.is_primary = true AND pi.expiration_date BETWEEN CURRENT_DATE AND (CURRENT_DATE + INTERVAL '60 days');"}, {"role": "user", "content": "Can you also include the insurance plan details and sort by expiration date?"}, {"role": "assistant", "content": "SELECT pi.patient_id, pi.policy_number, pi.subscriber_name, pi.plan_id, pi.effective_date, pi.expiration_date FROM healthcare.patient_insurance pi WHERE pi.is_primary = true AND pi.expiration_date BETWEEN CURRENT_DATE AND (CURRENT_DATE + INTERVAL '60 days') ORDER BY pi.expiration_date ASC;"}, {"role": "user", "content": "Actually, I need to see only patients whose insurance plans have a group number specified."}, {"role": "assistant", "content": "SELECT pi.patient_id, pi.policy_number, pi.subscriber_name, pi.plan_id, pi.group_number, pi.effective_date, pi.expiration_date FROM healthcare.patient_insurance pi WHERE pi.is_primary = true AND pi.expiration_date BETWEEN CURRENT_DATE AND (CURRENT_DATE + INTERVAL '60 days') AND pi.group_number IS NOT NULL ORDER BY pi.expiration_date ASC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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.medical_records ( record_id text PRIMARY KEY, patient_id text, appointment_id text, doctor_id text, record_date timestamp, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals text, created_at timestamp )\nCREATE TABLE healthcare.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.patient_insurance ( patient_insurance_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, plan_id character varying(64) NOT NULL, policy_number character varying(100) NOT NULL, group_number character varying(100), subscriber_name character varying(200), effective_date date NOT NULL, expiration_date date, is_primary boolean NOT NULL DEFAULT true, PRIMARY KEY (patient_insurance_id), UNIQUE (patient_id, plan_id, policy_number) )\n"}
{"conversations": [{"role": "user", "content": "List all fuel refueling events with the refueled vehicle's make and model, the fuel type used, and the fueling location ID."}, {"role": "assistant", "content": "SELECT fl.fuel_log_id, fl.log_timestamp, v.make, v.model, fl.fuel_type, fl.quantity, fl.unit, fl.total_cost, fl.location_id\nFROM transportation.fuel_logs fl\nJOIN transportation.vehicles v ON fl.vehicle_id = v.vehicle_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.vehicles ( vehicle_id text PRIMARY KEY, license_plate text, vin text, make text, model text, year int, type text, capacity int, fuel_type text, status text, depot_id text, acquisition_date date )\nCREATE TABLE transportation.drivers ( driver_id.text, employee_id.text, first_name.text, last_name.text, license_number.text, license_expiry_date.date, contact_number.text, email.text, hire_date.date, status.text )\nCREATE TABLE transportation.routes ( route_id text, route_number text, description text, origin_location_id text, destination_location_id text, distance_km numeric, estimated_duration_minutes integer, type text )\nCREATE TABLE transportation.trips ( trip_id text, route_id text, vehicle_id text, driver_id text, scheduled_departure timestamp, actual_departure timestamp, scheduled_arrival timestamp, actual_arrival timestamp, origin_location_id text, destination_location_id text, status text, passenger_count integer, cargo_manifest_id text )\nCREATE TABLE transportation.maintenance_logs (\n    log_id character varying(64) NOT NULL,  -- unique identifier for the maintenance record\n    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle serviced\n    service_date date NOT NULL, -- date the service was performed\n    odometer_reading integer, -- vehicle mileage at time of service\n    service_type character varying(128) NOT NULL, -- type of service (e.g., Oil Change, Tire Rotation, Engine Repair)\n    description text NOT NULL, -- detailed description of work done\n    cost numeric(10, 2), -- cost of the service\n    mechanic_name character varying(128), -- name or ID of the mechanic/shop\n    next_service_due_date date, -- recommended date for next service\n    PRIMARY KEY (log_id)\n)\nCREATE TABLE transportation.fuel_logs (\n    fuel_log_id character varying(64) NOT NULL,  -- unique identifier for the fuel log entry\n    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle fueled\n    trip_id character varying(64), -- optional: identifier of the trip during which fueling occurred\n    log_timestamp timestamp with time zone NOT NULL, -- time when fueling occurred\n    fuel_type character varying(32) NOT NULL, -- type of fuel added (matches vehicle's fuel type)\n    quantity numeric(10, 3) NOT NULL, -- amount of fuel added (e.g., Liters, Gallons, kWh)\n    unit character varying(16) NOT NULL, -- unit of quantity (e.g., L, gal, kWh)\n    cost_per_unit numeric(8, 4), -- price per unit of fuel\n    total_cost numeric(10, 2) NOT NULL, -- total cost of the fuel purchase\n    odometer_reading integer, -- vehicle mileage at time of fueling\n    location_id character varying(64), -- identifier of the fueling station/location\n    PRIMARY KEY (fuel_log_id)\n)\nCREATE TABLE transportation.bookings ( booking_id character varying(64) NOT NULL, passenger_id character varying(64) NOT NULL, trip_id character varying(64) NOT NULL, seat_number character varying(16), booking_time timestamp with time zone NOT NULL, status character varying(32) NOT NULL, fare numeric(10, 2) NOT NULL, payment_transaction_id character varying(128), special_requests text, PRIMARY KEY (booking_id) )\n"}
{"conversations": [{"role": "user", "content": "Show me all loans (loan_id, loan_type, principal_amount) where the current principal balance is less than 30% of the original principal amount, along with their account_id and status."}, {"role": "assistant", "content": "SELECT loan_id, loan_type, principal_amount, account_id, status FROM financial_services.loans WHERE current_principal_balance < 0.3 * principal_amount;"}, {"role": "user", "content": "Now modify the query to only include active loans (status = 'Active') and sort them by principal_amount in descending order."}, {"role": "assistant", "content": "SELECT loan_id, loan_type, principal_amount, account_id, status FROM financial_services.loans WHERE current_principal_balance < 0.3 * principal_amount AND status = 'Active' ORDER BY principal_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.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 properties in California with their star ratings and the total number of rooms they have, ordered by the room count in descending order."}, {"role": "assistant", "content": "SELECT p.property_id, p.property_name, p.star_rating, COUNT(r.room_id) AS room_count FROM hospitality_technology.properties p LEFT JOIN hospitality_technology.rooms r ON p.property_id = r.property_id WHERE p.state_province = 'California' GROUP BY p.property_id, p.property_name, p.star_rating ORDER BY room_count DESC;"}, {"role": "user", "content": "Now, include only properties with a star rating of 4.0 or higher and show the average base rate of their room types."}, {"role": "assistant", "content": "SELECT p.property_id, p.property_name, p.star_rating, COUNT(r.room_id) AS room_count, AVG(rt.base_rate) AS avg_base_rate FROM hospitality_technology.properties p LEFT JOIN hospitality_technology.rooms r ON p.property_id = r.property_id LEFT JOIN hospitality_technology.room_types rt ON p.property_id = rt.property_id WHERE p.state_province = 'California' AND p.star_rating >= 4.0 GROUP BY p.property_id, p.property_name, p.star_rating ORDER BY room_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties ( property_id character varying(64) NOT NULL, property_name character varying(255) NOT NULL, address_line1 character varying(255) NOT NULL, address_line2 character varying(255), city character varying(100) NOT NULL, state_province character varying(100), postal_code character varying(20) NOT NULL, country_code character varying(3) NOT NULL, phone_number character varying(30), email_address character varying(255), property_type character varying(50) NOT NULL, star_rating numeric(2,1), timezone character varying(64) NOT NULL, manager_staff_id character varying(64), created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (property_id) )\nCREATE TABLE hospitality_technology.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.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 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 (\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 ( 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 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 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": "Calculate for each player the timespan between their earliest and latest achievement unlocks."}, {"role": "assistant", "content": "SELECT pa_min.player_id,\n       pa_max.max_time - pa_min.min_time AS span\nFROM (\n  SELECT player_id,\n         MIN(unlocked_at) AS min_time\n  FROM gaming_technology.player_achievements\n  GROUP BY player_id\n) pa_min\nJOIN (\n  SELECT player_id,\n         MAX(unlocked_at) AS max_time\n  FROM gaming_technology.player_achievements\n  GROUP BY player_id\n) pa_max\n  ON pa_min.player_id = pa_max.player_id;"}, {"role": "user", "content": "Exclude players who only have one achievement."}, {"role": "assistant", "content": "WITH extremes AS (\n  SELECT player_id,\n         MIN(unlocked_at) AS min_time,\n         MAX(unlocked_at) AS max_time,\n         COUNT(*) AS cnt\n  FROM gaming_technology.player_achievements\n  GROUP BY player_id\n  HAVING COUNT(*) > 1\n)\nSELECT player_id,\n       max_time - min_time AS span\nFROM extremes;"}, {"role": "user", "content": "Also only keep players where the span is greater than 30 days."}, {"role": "assistant", "content": "WITH extremes AS (\n  SELECT player_id,\n         MIN(unlocked_at) AS min_time,\n         MAX(unlocked_at) AS max_time,\n         COUNT(*) AS cnt\n  FROM gaming_technology.player_achievements\n  GROUP BY player_id\n  HAVING COUNT(*) > 1\n)\nSELECT player_id,\n       max_time - min_time AS span\nFROM extremes\nWHERE max_time - min_time > 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 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 average ROI and average realized_ratio for each chain?"}, {"role": "assistant", "content": "SELECT chain,\n       AVG(roi) AS avg_roi,\n       AVG(realized_ratio) AS avg_realized_ratio\nFROM smart_money_token_performance\nGROUP BY chain;"}, {"role": "user", "content": "Now filter to only include chains where average ROI is above 0.5."}, {"role": "assistant", "content": "WITH stats AS (\n  SELECT chain,\n         AVG(roi) AS avg_roi,\n         AVG(realized_ratio) AS avg_realized_ratio\n  FROM smart_money_token_performance\n  GROUP BY chain\n)\nSELECT chain, avg_roi, avg_realized_ratio\nFROM stats\nWHERE avg_roi > 0.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 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": "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": "For each route type, show the total number of trips taken and the total distance covered across all trips for that type."}, {"role": "assistant", "content": "SELECT T1.type, COUNT(T2.trip_id), SUM(T1.distance_km) FROM transportation.routes AS T1 JOIN transportation.trips AS T2 ON T1.route_id = T2.route_id GROUP BY T1.type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.vehicles ( vehicle_id.text, license_plate.text, vin.text, make.text, model.text, year.integer, type.text, capacity.integer, fuel_type.text, status.text, depot_id.text, acquisition_date.date )\nCREATE TABLE transportation.drivers ( driver_id.text, employee_id.text, first_name.text, last_name.text, license_number.text, license_expiry_date.date, contact_number.text, email.text, hire_date.date, status.text )\nCREATE TABLE transportation.routes ( route_id.text, route_number.text, description.text, origin_location_id.text, destination_location_id.text, distance_km.numeric, estimated_duration_minutes.integer, type.text )\nCREATE TABLE transportation.trips ( trip_id.text, route_id.text, vehicle_id.text, driver_id.text, scheduled_departure.timestamp, actual_departure.timestamp, scheduled_arrival.timestamp, actual_arrival.timestamp, origin_location_id.text, destination_location_id.text, status.text, passenger_count.integer, cargo_manifest_id.text )\nCREATE TABLE transportation.fuel_logs ( fuel_log_id.text, vehicle_id.text, trip_id.text, log_timestamp.timestamp, fuel_type.text, quantity.numeric, unit.text, cost_per_unit.numeric, total_cost.numeric, odometer_reading.integer, location_id.text )\nCREATE TABLE transportation.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 WHERE tm.is_erc20 = 1 ORDER BY CAST(tm.total_supply AS decimal) DESC LIMIT 5;"}, {"role": "user", "content": "I think there's a typo in your query - it should be 'total_supply' not 'total_supply'. Also, can you join this with the token_prices_latest table to include the current price of each token?"}, {"role": "assistant", "content": "SELECT tm.name, tm.contract_address, tm.total_supply, tpl.price 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": "The token_prices_latest table isn't in the schema. Can you modify the query to use the erc20_balances table instead to show the total balance held across all wallets for each token?"}, {"role": "assistant", "content": "SELECT tm.name, tm.contract_address, tm.total_supply, SUM(CAST(eb.amount AS decimal)) AS total_balance FROM token_metas tm JOIN erc20_balances eb ON tm.contract_address = eb.contract_address WHERE tm.is_erc20 = 1 GROUP BY tm.name, tm.contract_address, tm.total_supply 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 (\n    block_timestamp timestamp(6) NOT NULL,  -- Timestamp of the block when token metadata was recorded\n    block_number bigint NOT NULL, -- Block number uniquely identifying the block\n    transaction_hash varchar NOT NULL, -- Hash value of the transaction\n    transaction_index bigint NOT NULL, -- Index of the transaction within the block\n    from_address varchar NOT NULL, -- Address from which the transaction originated\n    contract_address varchar NOT NULL, -- Address of the token contract\n    symbol varchar NOT NULL, -- Symbol of the token\n    total_supply varchar NOT NULL, -- erc20 contract total supply\n    name varchar NOT NULL, -- Name of the token\n    decimals bigint NOT NULL, -- Number of decimal places for the token\n    is_erc20 integer NOT NULL, -- Flag indicating if the token is an ERC-20 token (0 or 1)\n    is_erc721 integer NOT NULL, -- Flag indicating if the token is an ERC-721 token (0 or 1)\n    is_erc1155 integer NOT NULL, -- Flag indicating if the token is an ERC-1155 token (0 or 1)\n    is_proxy integer NOT NULL, -- Flag indicating if the token is a proxy (0 or 1)\n    extra_info varchar NOT NULL, -- Additional information about the token\n    pk integer NOT NULL  -- Partition key for the table(floor(block_number / 5760))\n)\nCREATE TABLE erc1155_approval_for_all (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction\n    transaction_index integer NOT NULL, -- Index of the transaction within the block\n    transaction_hash varchar(66) NOT NULL, -- Transaction hash\n    log_index integer NOT NULL, -- Log index\n    contract_address varchar(42) NOT NULL  -- Event contract address\n)\nCREATE TABLE erc20_balances ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE nft_holders (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    contract_address varchar NOT NULL, -- Event contract address\n    wallet_address varchar NOT NULL, -- The wallet address for the contract(with bloom filter)\n    token_id varchar NOT NULL, -- NFT token id\n    contract_type varchar NOT NULL, -- NFT contract type\n    amount varchar NOT NULL, -- Number of held NFTs\n    pk varchar NOT NULL  -- The last string partition of the contract.\n)\nCREATE TABLE 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_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 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_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 (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    log_index integer NOT NULL, -- Index of the log within the transaction\n    type varchar NOT NULL, -- mint | transfer | burn\n    tick varchar NOT NULL, -- Token tick\n    id varchar(255) NOT NULL, -- Unique identifier of the inscription\n    amt decimal(38,0) NOT NULL, -- Mint amount\n    from_address varchar(42) NOT NULL, -- Address sending the inscription (matches from_address in transactions table)\n    to_address varchar(42) NOT NULL  -- Address receiving the inscription (match to_address in transactions table)\n)\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 )\n"}
{"conversations": [{"role": "user", "content": "For all chains, which token held by centralized exchanges (CEX) has the highest ROI according to smart money token performance? Show token symbol, chain, exchange, total USD value held on CEX, and the smart money ROI."}, {"role": "assistant", "content": "SELECT c.token_symbol, c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, s.roi\nFROM cex_token_balance c\nJOIN smart_money_token_performance s ON c.token_symbol = s.token_symbol AND c.chain = s.chain\nGROUP BY c.token_symbol, c.chain, c.exchange, s.roi\nORDER BY s.roi DESC\nLIMIT 1;"}, {"role": "user", "content": "Instead of just the top one, show the top 3 tokens by ROI, and only include cases where the total USD value held on CEX is greater than $2,000,000."}, {"role": "assistant", "content": "SELECT c.token_symbol, c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, s.roi\nFROM cex_token_balance c\nJOIN smart_money_token_performance s ON c.token_symbol = s.token_symbol AND c.chain = s.chain\nGROUP BY c.token_symbol, c.chain, c.exchange, s.roi\nHAVING SUM(c.usd_value) > 2000000\nORDER BY s.roi DESC\nLIMIT 3;"}, {"role": "user", "content": "Add the last recorded price for each token, and sort by total_usd_value in descending order."}, {"role": "assistant", "content": "SELECT c.token_symbol, c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, s.roi, MAX(c.price) AS last_price\nFROM cex_token_balance c\nJOIN smart_money_token_performance s ON c.token_symbol = s.token_symbol AND c.chain = s.chain\nGROUP BY c.token_symbol, c.chain, c.exchange, s.roi\nHAVING SUM(c.usd_value) > 2000000\nORDER BY total_usd_value DESC\nLIMIT 3;"}, {"role": "user", "content": "I got duplicate tokens across exchanges. Can you show only the top exchange (with the greatest USD value) per token and chain combination?"}, {"role": "assistant", "content": "WITH cex_totals AS (\n  SELECT c.token_symbol, c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, s.roi, MAX(c.price) AS last_price,\n         ROW_NUMBER() OVER (PARTITION BY c.token_symbol, c.chain ORDER BY SUM(c.usd_value) DESC) as rn\n  FROM cex_token_balance c\n  JOIN smart_money_token_performance s ON c.token_symbol = s.token_symbol AND c.chain = s.chain\n  GROUP BY c.token_symbol, c.chain, c.exchange, s.roi\n  HAVING SUM(c.usd_value) > 2000000\n)\nSELECT token_symbol, chain, exchange, total_usd_value, roi, last_price\nFROM cex_totals\nWHERE rn = 1\nORDER BY total_usd_value 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, 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 narrative_info ( narrative character varying(512) NOT NULL, top_3_coins text, price_change_percentage_1h double precision, price_change_percentage_24h double precision, price_change_percentage_7d double precision, market_cap double precision, volume_24h double precision, trend_rank bigint, token_num bigint )\nCREATE TABLE cex_token_balance ( snapshot_time character varying(32) NOT NULL, chain character varying(128) NOT NULL, address character varying(128) NOT NULL, exchange character varying(512) NOT NULL, token_address character varying(128) NOT NULL, token_symbol character varying(512), balance numeric(38,10), usd_value numeric(38,14), price double precision )\nCREATE TABLE smart_money_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) )\nCREATE TABLE smart_money_token_performance ( token_address character varying(100) NOT NULL, token_symbol character varying(100), pnl numeric(38,2), net_flow numeric(38,2), avg_cost numeric(38,16), price double precision, realized_ratio numeric(10,2), roi numeric(10,2), chain character varying(100) )\nCREATE TABLE smart_money_token_inflow ( token_address character varying(100) NOT NULL, token_symbol character varying(100), token_amount numeric(38,2), usd_value numeric(38,2), avg_price numeric(38,6), type int, address_amount integer, narrative character varying(100), chain character varying(100) )\n"}
{"conversations": [{"role": "user", "content": "Can you provide a breakdown of total and average account balance by account_type and currency for each account status?"}, {"role": "assistant", "content": "SELECT account_type, currency, status, COUNT(*) AS total_accounts, SUM(balance) AS total_balance, AVG(balance) AS average_balance\nFROM financial_services.accounts\nGROUP BY account_type, currency, status;"}, {"role": "user", "content": "Could you include the minimum and maximum interest rate for each group as well?"}, {"role": "assistant", "content": "SELECT account_type, currency, status, COUNT(*) AS total_accounts, SUM(balance) AS total_balance, AVG(balance) AS average_balance, MIN(interest_rate) AS min_interest_rate, MAX(interest_rate) AS max_interest_rate\nFROM financial_services.accounts\nGROUP BY account_type, currency, status;"}, {"role": "user", "content": "Only show groups where the total_accounts is greater than 20."}, {"role": "assistant", "content": "SELECT account_type, currency, status, COUNT(*) AS total_accounts, SUM(balance) AS total_balance, AVG(balance) AS average_balance, MIN(interest_rate) AS min_interest_rate, MAX(interest_rate) AS max_interest_rate\nFROM financial_services.accounts\nGROUP BY account_type, currency, status\nHAVING COUNT(*) > 20;"}, {"role": "user", "content": "Please sort the results by average_balance in descending order."}, {"role": "assistant", "content": "SELECT account_type, currency, status, COUNT(*) AS total_accounts, SUM(balance) AS total_balance, AVG(balance) AS average_balance, MIN(interest_rate) AS min_interest_rate, MAX(interest_rate) AS max_interest_rate\nFROM financial_services.accounts\nGROUP BY account_type, currency, status\nHAVING COUNT(*) > 20\nORDER BY average_balance DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE financial_services.accounts (\n    account_id character varying(64) NOT NULL, -- unique identifier for the account\n    customer_id character varying(64) NOT NULL, -- foreign key linking to the customer\n    account_number character varying(128) NOT NULL UNIQUE, -- unique account number visible to customer\n    account_type character varying(50) NOT NULL, -- e.g., Checking, Savings, Investment, Loan, Credit Card\n    balance numeric(19, 4) NOT NULL DEFAULT 0.00, -- current account balance\n    currency character varying(3) NOT NULL, -- currency code (e.g., USD, EUR)\n    opened_date date NOT NULL, -- date the account was opened\n    status character varying(32) NOT NULL, -- e.g., Open, Closed, Frozen\n    interest_rate numeric(5, 4), -- annual interest rate, if applicable\n    last_updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- timestamp of last account update\n    PRIMARY KEY (account_id),\n    FOREIGN KEY (customer_id) REFERENCES financial_services.customers(customer_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all events and any token transfers that occurred in the same transaction, showing event_id, event_name, transfer_id, and token_symbol."}, {"role": "assistant", "content": "SELECT\n  e.event_id,\n  e.event_name,\n  tt.transfer_id,\n  tk.token_symbol\nFROM web3.events e\nLEFT JOIN web3.token_transfers tt\n  ON e.transaction_id = tt.transaction_id\nLEFT JOIN web3.tokens tk\n  ON tt.token_id = tk.token_id\nORDER BY e.transaction_id, e.log_index;"}], "system": "You are an SQL statement expert. Given the table structure 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.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.users ( user_id text, username text, email text, password_hash text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show the total transaction amount for each customer, including their full name and risk profile. Join customers to accounts and then to transactions."}, {"role": "assistant", "content": "SELECT\n  T2.first_name,\n  T2.last_name,\n  T2.risk_profile,\n  SUM(T1.amount) AS total_transaction_amount\nFROM financial_services.transactions AS T1\nINNER JOIN financial_services.accounts AS T3\n  ON T1.account_id = T3.account_id\nINNER JOIN financial_services.customers AS T2\n  ON T3.customer_id = T2.customer_id\nGROUP BY\n  T2.customer_id,\n  T2.first_name,\n  T2.last_name,\n  T2.risk_profile;"}, {"role": "user", "content": "Filter this report to only include transactions from the last 90 days."}, {"role": "assistant", "content": "SELECT\n  T2.first_name,\n  T2.last_name,\n  T2.risk_profile,\n  SUM(T1.amount) AS total_transaction_amount\nFROM financial_services.transactions AS T1\nINNER JOIN financial_services.accounts AS T3\n  ON T1.account_id = T3.account_id\nINNER JOIN financial_services.customers AS T2\n  ON T3.customer_id = T2.customer_id\nWHERE\n  T1.transaction_date >= CURRENT_DATE - INTERVAL '90 days'\nGROUP BY\n  T2.customer_id,\n  T2.first_name,\n  T2.last_name,\n  T2.risk_profile;"}, {"role": "user", "content": "Also, only include customers whose total transaction amount in this period exceeds 1000."}, {"role": "assistant", "content": "SELECT\n  T2.first_name,\n  T2.last_name,\n  T2.risk_profile,\n  SUM(T1.amount) AS total_transaction_amount\nFROM financial_services.transactions AS T1\nINNER JOIN financial_services.accounts AS T3\n  ON T1.account_id = T3.account_id\nINNER JOIN financial_services.customers AS T2\n  ON T3.customer_id = T2.customer_id\nWHERE\n  T1.transaction_date >= CURRENT_DATE - INTERVAL '90 days'\nGROUP BY\n  T2.customer_id,\n  T2.first_name,\n  T2.last_name,\n  T2.risk_profile\nHAVING\n  SUM(T1.amount) > 1000;"}, {"role": "user", "content": "Sort the results by total transaction amount in descending order and limit to the top 10 customers."}, {"role": "assistant", "content": "SELECT\n  T2.first_name,\n  T2.last_name,\n  T2.risk_profile,\n  SUM(T1.amount) AS total_transaction_amount\nFROM financial_services.transactions AS T1\nINNER JOIN financial_services.accounts AS T3\n  ON T1.account_id = T3.account_id\nINNER JOIN financial_services.customers AS T2\n  ON T3.customer_id = T2.customer_id\nWHERE\n  T1.transaction_date >= CURRENT_DATE - INTERVAL '90 days'\nGROUP BY\n  T2.customer_id,\n  T2.first_name,\n  T2.last_name,\n  T2.risk_profile\nHAVING\n  SUM(T1.amount) > 1000\nORDER BY\n  total_transaction_amount DESC\nLIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE financial_services.customers ( customer_id text, first_name text, last_name text, date_of_birth date, ssn_hash text, address text, city text, state text, zip_code text, country text, email text, phone_number text, created_at timestamp, status text, risk_profile text )\nCREATE TABLE financial_services.accounts ( account_id text, customer_id text, account_number text, account_type text, balance numeric, currency text, opened_date date, status text, interest_rate numeric, last_updated_at timestamp )\nCREATE TABLE financial_services.transactions (\n    transaction_id character varying(64) NOT NULL, -- unique identifier for the transaction\n    account_id character varying(64) NOT NULL, -- account involved in the transaction\n    related_account_id character varying(64), -- counterpart account for transfers\n    transaction_type character varying(50) NOT NULL, -- e.g., Deposit, Withdrawal, Transfer, Payment, Fee, Interest\n    amount numeric(19, 4) NOT NULL, -- transaction amount\n    currency character varying(3) NOT NULL, -- transaction currency\n    transaction_date timestamp NOT NULL, -- exact time of the transaction\n    effective_date date NOT NULL, -- date the transaction affects the balance\n    description text, -- description or memo of the transaction\n    status character varying(32) NOT NULL, -- e.g., Pending, Completed, Failed, Reversed\n    reference_number character varying(128), -- external reference if applicable (e.g., check number)\n    PRIMARY KEY (transaction_id),\n    FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id),\n    FOREIGN KEY (related_account_id) REFERENCES financial_services.accounts(account_id)\n)\nCREATE TABLE financial_services.securities ( security_id.text, ticker_symbol.text, isin_code.text, cusip_code.text, security_name.text, security_type.text, exchange.text, currency.text, issuer_name.text, sector.text, last_updated.timestamp )\nCREATE TABLE financial_services.trades ( trade_id text PRIMARY KEY, account_id text, security_id text, order_id text, trade_type text, quantity numeric, price_per_unit numeric, total_amount numeric, commission numeric, trade_timestamp timestamp, settlement_date date, status text, execution_venue text )\nCREATE TABLE financial_services.market_data ( data_point_id.bigint, security_id.text, data_timestamp.timestamp, open_price.numeric, high_price.numeric, low_price.numeric, close_price.numeric, adjusted_close_price.numeric, volume.bigint, source.text )\nCREATE TABLE financial_services.employees (\n    employee_id character varying(64) NOT NULL,  -- unique identifier for the employee\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    job_title character varying(100) NOT NULL, -- e.g., Teller, Branch Manager, Financial Advisor, Analyst\n    department character varying(100), -- e.g., Retail Banking, Wealth Management, IT\n    branch_id character varying(64), -- Identifier for the branch they work at (if applicable)\n    email character varying(128) NOT NULL UNIQUE,\n    phone_extension character varying(20),\n    hire_date date NOT NULL,\n    termination_date date, -- Date of termination, null if currently employed\n    manager_id character varying(64), -- Self-referencing key for manager relationship\n    status character varying(32) NOT NULL, -- e.g., Active, Terminated, On Leave\n    PRIMARY KEY (employee_id),\n    FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), -- Assuming a branches table exists\n    FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show the name and symbol for all assets in the system."}, {"role": "assistant", "content": "SELECT name, symbol FROM assets;"}, {"role": "user", "content": "Now, include any associated metadata key and value for each asset. If an asset has no metadata, it should still be listed."}, {"role": "assistant", "content": "SELECT T1.name, T1.symbol, T2.key, T2.value FROM assets AS T1 LEFT JOIN metadata AS T2 ON T1.asset_id = T2.asset_id;"}, {"role": "user", "content": "Filter the results to only show entries where the metadata key contains the word 'description' and the asset type is 'cryptocurrency'."}, {"role": "assistant", "content": "SELECT T1.name, T1.symbol, T2.key, T2.value FROM assets AS T1 LEFT JOIN metadata AS T2 ON T1.asset_id = T2.asset_id WHERE T2.key LIKE '%description%' AND T1.type = 'cryptocurrency';"}, {"role": "user", "content": "Sort the final list by asset name alphabetically."}, {"role": "assistant", "content": "SELECT T1.name, T1.symbol, T2.key, T2.value FROM assets AS T1 LEFT JOIN metadata AS T2 ON T1.asset_id = T2.asset_id WHERE T2.key LIKE '%description%' AND T1.type = 'cryptocurrency' ORDER BY T1.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 trading_platform.users ( user_id text PRIMARY KEY, username text, email text, password_hash text, created_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.dapps ( dapp_id.text, name.text, description.text, url.text )\nCREATE TABLE trading_platform.peers ( peer_id character varying(64) NOT NULL, ip_address character varying(15) NOT NULL, port integer NOT NULL, last_seen timestamp NOT NULL, PRIMARY KEY (peer_id) )\nCREATE TABLE trading_platform.metadata (\n    metadata_id character varying(64) NOT NULL,  -- unique identifier for the metadata\n    asset_id character varying(64) NOT NULL, -- identifier of the asset the metadata is associated with\n    key character varying(128) NOT NULL, -- key of the metadata\n    value text NOT NULL, -- value of the metadata\n    PRIMARY KEY (metadata_id)\n)\nCREATE TABLE trading_platform.kyc_audit ( kyc_audit_id.text, user_id.text, status.text, reviewed_at.timestamp )\nCREATE TABLE trading_platform.logs (\n    log_id character varying(64) NOT NULL,  -- unique identifier for the log entry\n    user_id character varying(64), -- identifier of the user associated with the log entry\n    action character varying(128) NOT NULL, -- action performed\n    details text NOT NULL, -- details of the action\n    logged_at timestamp NOT NULL, -- time when the log entry was created\n    PRIMARY KEY (log_id)\n)\nCREATE TABLE trading_platform.notifications ( notification_id.text, user_id.text, message.text, sent_at.timestamp, read_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "Which staff members are managing properties, and what are the names and email addresses of those properties?"}, {"role": "assistant", "content": "SELECT s.staff_id, s.first_name, s.last_name, p.property_name, p.email_address FROM hospitality_technology.staff s INNER JOIN hospitality_technology.properties p ON s.staff_id = p.manager_staff_id;"}, {"role": "user", "content": "Only include properties located in the United States and list the staff position as well."}, {"role": "assistant", "content": "SELECT s.staff_id, s.first_name, s.last_name, s.position, p.property_name, p.email_address FROM hospitality_technology.staff s INNER JOIN hospitality_technology.properties p ON s.staff_id = p.manager_staff_id WHERE p.country_code = 'US';"}], "system": "You are an SQL statement expert. Given the table structure 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.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.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 )\n"}
{"conversations": [{"role": "user", "content": "I need to find pairs of players who share the same email domain. For each pair, return player1_id, player2_id, and the shared domain."}, {"role": "assistant", "content": "SELECT p1.player_id AS player1_id,\n       p2.player_id AS player2_id,\n       LOWER(SPLIT_PART(p1.email, '@', 2)) AS domain\nFROM gaming_technology.players p1\nJOIN gaming_technology.players p2\n  ON LOWER(SPLIT_PART(p1.email, '@', 2)) = LOWER(SPLIT_PART(p2.email, '@', 2));"}, {"role": "user", "content": "Actually, I only want each combination once, so ensure player1_id is always less than player2_id."}, {"role": "assistant", "content": "SELECT p1.player_id AS player1_id,\n       p2.player_id AS player2_id,\n       LOWER(SPLIT_PART(p1.email, '@', 2)) AS domain\nFROM gaming_technology.players p1\nJOIN gaming_technology.players p2\n  ON LOWER(SPLIT_PART(p1.email, '@', 2)) = LOWER(SPLIT_PART(p2.email, '@', 2))\nWHERE p1.player_id < p2.player_id;"}, {"role": "user", "content": "Also exclude any domain that appears only once among all players."}, {"role": "assistant", "content": "SELECT p1.player_id AS player1_id,\n       p2.player_id AS player2_id,\n       d.domain\nFROM (\n  SELECT LOWER(SPLIT_PART(email, '@', 2)) AS domain\n  FROM gaming_technology.players\n  GROUP BY domain\n  HAVING COUNT(*) > 1\n) d\nJOIN gaming_technology.players p1\n  ON LOWER(SPLIT_PART(p1.email, '@', 2)) = d.domain\nJOIN gaming_technology.players p2\n  ON LOWER(SPLIT_PART(p2.email, '@', 2)) = d.domain\nWHERE p1.player_id < p2.player_id;"}, {"role": "user", "content": "Finally, order the results by domain ascending and then by player1_id."}, {"role": "assistant", "content": "SELECT p1.player_id AS player1_id,\n       p2.player_id AS player2_id,\n       d.domain\nFROM (\n  SELECT LOWER(SPLIT_PART(email, '@', 2)) AS domain\n  FROM gaming_technology.players\n  GROUP BY domain\n  HAVING COUNT(*) > 1\n) d\nJOIN gaming_technology.players p1\n  ON LOWER(SPLIT_PART(p1.email, '@', 2)) = d.domain\nJOIN gaming_technology.players p2\n  ON LOWER(SPLIT_PART(p2.email, '@', 2)) = d.domain\nWHERE p1.player_id < p2.player_id\nORDER BY d.domain ASC, p1.player_id 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.players ( player_id.uuid, username.text, email.text, password_hash.text, registration_date.timestamptz, last_login.timestamptz, country_code.text, status.text, profile_data.jsonb )\n"}
{"conversations": [{"role": "user", "content": "How many services are defined for each service category?"}, {"role": "assistant", "content": "SELECT category, COUNT(*) AS service_count FROM government_services.services GROUP BY category;"}, {"role": "user", "content": "Only show categories that have more than 15 services listed."}, {"role": "assistant", "content": "SELECT category, COUNT(*) AS service_count FROM government_services.services GROUP BY category HAVING COUNT(*) > 15;"}, {"role": "user", "content": "Could you only count services that are currently marked as active?"}, {"role": "assistant", "content": "SELECT category, COUNT(*) AS service_count FROM government_services.services WHERE is_active = true GROUP BY category HAVING COUNT(*) > 15;"}, {"role": "user", "content": "Also, for these categories, provide the average standard fee for the active services."}, {"role": "assistant", "content": "SELECT category, COUNT(*) AS service_count, AVG(standard_fee) AS average_fee FROM government_services.services WHERE is_active = true GROUP BY category HAVING COUNT(*) > 15;"}], "system": "You are an SQL statement expert. Given the table structure 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 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.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 the trip ID, route number, vehicle ID, and the total fuel cost associated with each trip."}, {"role": "assistant", "content": "SELECT t.trip_id, r.route_number, t.vehicle_id, SUM(fl.total_cost) AS total_fuel_cost FROM transportation.trips t JOIN transportation.routes r ON t.route_id = r.route_id JOIN transportation.fuel_logs fl ON t.trip_id = fl.trip_id GROUP BY t.trip_id, r.route_number, t.vehicle_id;"}, {"role": "user", "content": "Only include trips where the total fuel cost is greater than 1000."}, {"role": "assistant", "content": "SELECT t.trip_id, r.route_number, t.vehicle_id, SUM(fl.total_cost) AS total_fuel_cost FROM transportation.trips t JOIN transportation.routes r ON t.route_id = r.route_id JOIN transportation.fuel_logs fl ON t.trip_id = fl.trip_id GROUP BY t.trip_id, r.route_number, t.vehicle_id HAVING SUM(fl.total_cost) > 1000;"}, {"role": "user", "content": "Also, order the results by total fuel cost in descending order."}, {"role": "assistant", "content": "SELECT t.trip_id, r.route_number, t.vehicle_id, SUM(fl.total_cost) AS total_fuel_cost FROM transportation.trips t JOIN transportation.routes r ON t.route_id = r.route_id JOIN transportation.fuel_logs fl ON t.trip_id = fl.trip_id GROUP BY t.trip_id, r.route_number, t.vehicle_id HAVING SUM(fl.total_cost) > 1000 ORDER 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 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, 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 )\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 )\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": "I want to list all insurance plans along with the number of medical records that have a record_date in 2024. Display plan_id, plan_name, and the total medical records."}, {"role": "assistant", "content": "SELECT ip.plan_id, ip.plan_name, COUNT(mr.record_id) AS total_medical_records\nFROM healthcare.insurance_plans ip\nLEFT JOIN healthcare.medical_records mr ON 1=0 -- there is no direct relationship in schema, so no records will be counted\nWHERE mr.record_date >= '2024-01-01' AND mr.record_date < '2025-01-01'\nGROUP BY ip.plan_id, ip.plan_name;"}, {"role": "user", "content": "Since there's no direct relationship, can you adjust it to just show all insurance plans of type 'EPO' with their plan_id and plan_name?"}, {"role": "assistant", "content": "SELECT plan_id, plan_name\nFROM healthcare.insurance_plans\nWHERE plan_type = 'EPO';"}], "system": "You are an SQL statement expert. Given the table structure 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)\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": "What is the total market cap for all tokens listed on the 'Polygon' chain?"}, {"role": "assistant", "content": "SELECT SUM(market_cap) FROM token_dexpool_info WHERE chain = 'Polygon';"}, {"role": "user", "content": "Only sum the market cap for tokens on 'Polygon' that have a 24-hour volume greater than 500000."}, {"role": "assistant", "content": "SELECT SUM(market_cap) FROM token_dexpool_info WHERE chain = 'Polygon' AND volume_24h > 500000;"}, {"role": "user", "content": "Also show the number of unique tokens that meet these criteria."}, {"role": "assistant", "content": "SELECT COUNT(DISTINCT token_symbol), SUM(market_cap) FROM token_dexpool_info WHERE chain = 'Polygon' AND volume_24h > 500000;"}, {"role": "user", "content": "Can you show the total market cap and token count for *each* chain that meets these volume criteria, ordered by total market cap descending?"}, {"role": "assistant", "content": "SELECT chain, COUNT(DISTINCT token_symbol) AS token_count, SUM(market_cap) AS total_market_cap FROM token_dexpool_info WHERE volume_24h > 500000 GROUP BY chain ORDER BY total_market_cap 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_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"}
{"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": "Could you list the trip ID, scheduled and actual arrival times, and the associated vehicle's make and model for all trips where the actual arrival was more than 30 minutes later than scheduled?"}, {"role": "assistant", "content": "SELECT T1.trip_id, T1.scheduled_arrival, T1.actual_arrival, T2.make, T2.model FROM transportation.trips AS T1 JOIN transportation.vehicles AS T2 ON T1.vehicle_id = T2.vehicle_id WHERE T1.actual_arrival IS NOT NULL AND T1.scheduled_arrival IS NOT NULL AND T1.actual_arrival > T1.scheduled_arrival + INTERVAL '30 minutes';"}, {"role": "user", "content": "Now, filter this list to only include trips that were completed within the last 6 months."}, {"role": "assistant", "content": "SELECT T1.trip_id, T1.scheduled_arrival, T1.actual_arrival, T2.make, T2.model FROM transportation.trips AS T1 JOIN transportation.vehicles AS T2 ON T1.vehicle_id = T2.vehicle_id WHERE T1.actual_arrival IS NOT NULL AND T1.scheduled_arrival IS NOT NULL AND T1.actual_arrival > T1.scheduled_arrival + INTERVAL '30 minutes' AND T1.actual_arrival >= NOW() - INTERVAL '6 months';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.drivers ( driver_id text PRIMARY KEY, employee_id text, first_name text, last_name text, license_number text, license_expiry_date date, contact_number text, email text, hire_date date, status text )\nCREATE TABLE transportation.routes ( route_id text 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.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 )\n"}
{"conversations": [{"role": "user", "content": "Show me the token names and their contract addresses where the total supply is greater than 1 million, sorted by total supply in descending order."}, {"role": "assistant", "content": "SELECT token_name, contract_address FROM web3.tokens WHERE total_supply > 1000000 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": "Which bed types are offered in each property and how many different room types are associated with each bed type?"}, {"role": "assistant", "content": "SELECT property_id, bed_type, COUNT(DISTINCT room_type_id) AS room_type_count FROM hospitality_technology.room_types GROUP BY property_id, bed_type;"}, {"role": "user", "content": "Now, show only bed types that are available for at least 3 different room types within the same property."}, {"role": "assistant", "content": "SELECT property_id, bed_type, COUNT(DISTINCT room_type_id) AS room_type_count FROM hospitality_technology.room_types GROUP BY property_id, bed_type HAVING COUNT(DISTINCT room_type_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 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me all log entries for user ID 'user123'."}, {"role": "assistant", "content": "SELECT log_id, user_id, action, details, logged_at FROM trading_platform.logs WHERE user_id = 'user123' ORDER BY logged_at DESC;"}, {"role": "user", "content": "Show only the logs for that user where the action contains 'trade' and the log entry was created after '2024-07-01'."}, {"role": "assistant", "content": "SELECT log_id, user_id, action, details, logged_at FROM trading_platform.logs WHERE user_id = 'user123' AND action LIKE '%trade%' AND logged_at > '2024-07-01' ORDER BY logged_at DESC;"}, {"role": "user", "content": "Instead of listing the logs, just count how many logs for user 'user123' meet the criteria (action contains 'trade' and logged after '2024-07-01')."}, {"role": "assistant", "content": "SELECT COUNT(*) FROM trading_platform.logs WHERE user_id = 'user123' AND action LIKE '%trade%' AND logged_at > '2024-07-01';"}, {"role": "user", "content": "Now, for that user ('user123') and timeframe (after '2024-07-01'), count how many unique action types containing 'trade' they performed."}, {"role": "assistant", "content": "SELECT COUNT(DISTINCT action) FROM trading_platform.logs WHERE user_id = 'user123' AND action LIKE '%trade%' AND logged_at > '2024-07-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.logs ( log_id character varying(64) NOT NULL, user_id character varying(64), action character varying(128) NOT NULL, details text NOT NULL, logged_at timestamp NOT NULL, PRIMARY KEY (log_id) )\n"}
{"conversations": [{"role": "user", "content": "List all NFT collections from the sui_nfts table where the owner is not null, including their name and collection_type."}, {"role": "assistant", "content": "SELECT name, collection_type FROM sui_nfts WHERE owner IS NOT NULL;"}, {"role": "user", "content": "Can you also include the display field and filter to only show collections with a package_id starting with '0x'?"}, {"role": "assistant", "content": "SELECT name, collection_type, display FROM sui_nfts WHERE owner IS NOT NULL AND package_id LIKE '0x%';"}, {"role": "user", "content": "Now sort these results by name in ascending order."}, {"role": "assistant", "content": "SELECT name, collection_type, display FROM sui_nfts WHERE owner IS NOT NULL AND package_id LIKE '0x%' ORDER BY name ASC;"}], "system": "You are an SQL statement expert. Given the table structure 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_historical ( block_number bigint, contract_address text, wallet_address text, amount text, pk integer )\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, contract_address.text, wallet_address.text, token_id.text, contract_type.text, amount.text, pk.integer )\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_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 (\n    blockchain varchar NOT NULL, -- blockchain fields for the functionType  in contract\n    contract_address varchar NOT NULL, -- Contract address(with bloom filter)\n    token_id varchar NOT NULL, -- The number of the token\n    contract_name varchar NOT NULL, -- contract_name fields for the functionType  in contract\n    erc_type varchar NOT NULL, -- The type of token\n    amount bigint NOT NULL, -- amount fields for the functionType  in contract\n    minter varchar NOT NULL, -- minter fields for the functionType  in contract\n    owner varchar NOT NULL, -- owner fields for the functionType  in contract\n    mint_block_number bigint NOT NULL, -- mint_block_number fields for the functionType  in contract\n    mint_time bigint NOT NULL, -- mint_time fields for the functionType  in contract\n    mint_transaction_hash varchar NOT NULL, -- mint_transaction_hash fields for the functionType  in contract\n    mint_price varchar NOT NULL, -- mint_price fields for the functionType  in contract\n    token_uri varchar NOT NULL, -- token_uri fields for the functionType  in contract\n    metadata varchar NOT NULL, -- metadata fields for the functionType  in contract\n    name varchar NOT NULL, -- name fields for the functionType  in contract\n    image_uri varchar NOT NULL, -- image_uri fields for the functionType  in contract\n    traits varchar NOT NULL, -- traits fields for the functionType  in contract\n    updated_at bigint NOT NULL, -- updated_at fields for the functionType  in contract\n    status varchar NOT NULL, -- status fields for the functionType  in contract\n    rarity_score real NOT NULL, -- rarity_score fields for the functionType  in contract\n    rarity_rank integer NOT NULL, -- rarity_rank fields for the functionType  in contract\n    unique_attribute_count integer NOT NULL, -- unique_attribute_count fields for the functionType  in contract\n    pk integer NOT NULL  -- Partition key for the table(floor(mint_time / 1000 / 86400 / 30))\n)\nCREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash varchar, log_index integer, contract_address varchar, pk integer )\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 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_info_bitcoin (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    tick varchar(255) NOT NULL, -- Ticker:  Identifier of the inscription\n    max_supply decimal(38,0) NOT NULL, -- Max supply: Set max supply of the inscription\n    lim decimal(38,0) NOT NULL, -- Mint limit: limit per inscription\n    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint\n    dec integer NOT NULL, -- Decimal for minimum divie\n    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)\n)\nCREATE TABLE token_activities_avalanche (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    log_index integer NOT NULL, -- Index of the log within the transaction\n    type varchar(20) NOT NULL, -- Operation: Type of event (deploy, mint, transfer, list)\n    tick varchar(255) NOT NULL, -- Ticker: Identifier of the inscription\n    id varchar(255) NOT NULL, -- Unique identifier of the inscription\n    amt decimal(38,0) NOT NULL, -- Amount to mint: States the amount of the inscription to operation. When operation is mint, has to be less or equal to \"lim\"\n    from_address varchar(42) NOT NULL, -- Address sending the inscription\n    to_address varchar(42) NOT NULL  -- Address receiving the inscription\n)\nCREATE TABLE token_balances_avalanche (\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)\n"}
{"conversations": [{"role": "user", "content": "What is the average ROI for smart money addresses on the Ethereum chain with a realized ratio above 70%?"}, {"role": "assistant", "content": "SELECT AVG(roi) FROM smart_money_profit WHERE chain = 'Ethereum' AND realized_ratio > 70;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE token_basic_info ( coin_id character varying(100) NOT NULL, -- 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, -- 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) )\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) )\nCREATE TABLE smart_money_token_performance ( token_address character varying(100) NOT NULL, -- the token's address token_symbol character varying(100), -- the tokens's symbol pnl numeric(38,2), -- the profit users made on this token net_flow numeric(38,2), -- the netflow of the token, means the money user spent minus the the money user sold of this token avg_cost numeric(38,16), -- the average cost price of user spent on this token price double precision, -- the current price of the token realized_ratio numeric(10,2), -- the ratio user sold of the token roi numeric(10,2), -- the roi users made of this token chain character varying(100), -- the chain that the token resides PRIMARY KEY (token_address, chain) )\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": "List the appointment ID, start time, and the case number for all appointments that are linked to a case."}, {"role": "assistant", "content": "SELECT T1.appointment_id, T1.start_time, T2.case_number FROM legal_services.appointments AS T1 JOIN legal_services.cases AS T2 ON T1.case_id = T2.case_id"}, {"role": "user", "content": "Refine this to only show appointments with status 'completed' associated with cases with status 'Closed'."}, {"role": "assistant", "content": "SELECT T1.appointment_id, T1.start_time, T2.case_number FROM legal_services.appointments AS T1 JOIN legal_services.cases AS T2 ON T1.case_id = T2.case_id WHERE T1.status = 'completed' AND T2.status = 'Closed'"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.cases ( case_id text, case_number text, case_name text, client_id text, lead_lawyer_id text, case_type text, status text, date_opened timestamp, date_closed timestamp, description text, court_jurisdiction text )\nCREATE TABLE legal_services.appointments ( appointment_id text, client_id text, lawyer_id text, case_id text, start_time timestamp, end_time timestamp, location text, subject text, notes text, status text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show me the number of service orders placed for each service category."}, {"role": "assistant", "content": "SELECT s.category, COUNT(so.order_id) AS order_count\nFROM hospitality_technology.service_orders so\nJOIN hospitality_technology.services s ON so.service_id = s.service_id\nGROUP BY s.category;"}, {"role": "user", "content": "Only include categories with more than 10 orders and order by order_count descending."}, {"role": "assistant", "content": "SELECT s.category, COUNT(so.order_id) AS order_count\nFROM hospitality_technology.service_orders so\nJOIN hospitality_technology.services s ON so.service_id = s.service_id\nGROUP BY s.category\nHAVING COUNT(so.order_id) > 10\nORDER BY order_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.guests ( guest_id text PRIMARY KEY, first_name text, last_name text, email text, phone_number text, date_of_birth date, address_line1 text, city text, state_province text, postal_code text, country_code text, preferences text, loyalty_member_id text, communication_consent boolean, created_at timestamp, updated_at timestamp )\nCREATE TABLE hospitality_technology.reservations ( reservation_id text PRIMARY KEY, property_id text, guest_id text, room_id text, room_type_id text, check_in_date date, check_out_date date, actual_check_in_ts timestamp, actual_check_out_ts timestamp, num_adults int, num_children int, status text, booking_source text, rate_plan_id text, total_amount numeric, amount_paid numeric, special_requests text, created_at timestamp, updated_at timestamp )\nCREATE TABLE hospitality_technology.staff ( staff_id text PRIMARY KEY, property_id text, first_name text, last_name text, position text, work_email text, work_phone text, hire_date date, termination_date date, is_active boolean, access_level int, manager_id text, created_at timestamp )\nCREATE TABLE hospitality_technology.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.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 each service's name along with the total number of appointments scheduled and the number of unique locations these appointments are scheduled at."}, {"role": "assistant", "content": "SELECT s.service_name, COUNT(a.application_id) AS appointment_count, COUNT(DISTINCT ap.location_id) AS unique_location_count\nFROM government_services.services s\nJOIN government_services.applications a ON s.service_id = a.service_id\nJOIN government_services.appointments ap ON a.application_id = ap.application_id\nGROUP BY s.service_name;"}, {"role": "user", "content": "I got an error: relation 'appointments' does not exist."}, {"role": "assistant", "content": "-- The appointments table is not present in the provided schema. If you want to count by another join, perhaps by documents or payments, please specify.\n-- Alternatively, do you want appointment information replaced with application submissions per service and their associated location from service_locations?\nSELECT s.service_name, COUNT(a.application_id) AS application_count, COUNT(DISTINCT sl.location_id) AS unique_location_count\nFROM government_services.services s\nJOIN government_services.applications a ON s.service_id = a.service_id\nJOIN government_services.service_locations sl ON s.agency_id = sl.agency_id\nGROUP BY s.service_name;"}, {"role": "user", "content": "Show only those services where application_count is greater than 50."}, {"role": "assistant", "content": "SELECT s.service_name, COUNT(a.application_id) AS application_count, COUNT(DISTINCT sl.location_id) AS unique_location_count\nFROM government_services.services s\nJOIN government_services.applications a ON s.service_id = a.service_id\nJOIN government_services.service_locations sl ON s.agency_id = sl.agency_id\nGROUP BY s.service_name\nHAVING COUNT(a.application_id) > 50;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens (\n    citizen_id character varying(64) NOT NULL,  -- unique identifier for the citizen\n    national_id_number character varying(128) NOT NULL UNIQUE, -- official national identification number\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    date_of_birth date NOT NULL,\n    gender character varying(20),\n    primary_address text NOT NULL, -- full primary residential address\n    contact_email character varying(128) UNIQUE,\n    contact_phone character varying(32),\n    registration_date timestamp NOT NULL, -- when the citizen profile was created\n    is_verified boolean DEFAULT false, -- whether identity has been officially verified\n    PRIMARY KEY (citizen_id)\n)\nCREATE TABLE government_services.agencies ( agency_id.text, agency_name.text, jurisdiction_level.text, primary_contact_email.text, main_phone_number.text, website_url.text, established_date.date, parent_agency_id.text )\nCREATE TABLE government_services.services ( service_id text PRIMARY KEY, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days int, is_active boolean, online_application_url text )\nCREATE TABLE government_services.applications ( application_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, service_id character varying(64) NOT NULL, submitted_at timestamp NOT NULL, status character varying(50) NOT NULL, last_updated_at timestamp NOT NULL, assigned_employee_id character varying(64), decision_date date, notes text, reference_number character varying(100) UNIQUE, PRIMARY KEY (application_id) )\nCREATE TABLE government_services.documents ( document_id.text, application_id.text, citizen_id.text, document_type.text, file_reference.text, upload_timestamp.timestamp, expiry_date.date, verification_status.text, verified_by_employee_id.text, verification_timestamp.timestamp )\nCREATE TABLE government_services.payments ( payment_id text, application_id text, citizen_id text, service_id text, amount numeric, currency text, payment_method text, payment_provider_reference text, payment_timestamp timestamp, status text, notes text )\nCREATE TABLE government_services.service_locations (\n    location_id character varying(64) NOT NULL, -- unique identifier for the physical location\n    agency_id character varying(64) NOT NULL, -- FK to agencies table\n    location_name character varying(200), -- e.g., Downtown DMV Office\n    address text NOT NULL,\n    city character varying(100),\n    state character varying(50),\n    postal_code character varying(20),\n    latitude numeric(9, 6),\n    longitude numeric(9, 6),\n    operating_hours text, -- description of opening times\n    contact_phone character varying(32),\n    is_accessible boolean, -- accessibility information (e.g., wheelchair access)\n    PRIMARY KEY (location_id)\n)\nCREATE TABLE government_services.notifications ( notification_id text PRIMARY KEY, citizen_id text, application_id text, message_subject text, message_body text, channel text, sent_at timestamp, status text, related_entity_type text, related_entity_id text )\n"}
{"conversations": [{"role": "user", "content": "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": "List all appointments showing the appointment ID, the citizen's full name, and the name of the service associated with the appointment."}, {"role": "assistant", "content": "SELECT appt.appointment_id, c.first_name || ' ' || c.last_name AS citizen_full_name, s.service_id AS service_id\nFROM government_services.appointments appt\nJOIN government_services.citizens c ON appt.citizen_id = c.citizen_id\nJOIN government_services.applications app ON app.citizen_id = c.citizen_id AND app.service_id = appt.service_id;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id.text, national_id_number.text, first_name.text, last_name.text, date_of_birth.date, gender.text, primary_address.text, contact_email.text, contact_phone.text, registration_date.timestamp, is_verified.boolean )\nCREATE TABLE government_services.agencies ( agency_id.text, agency_name.text, jurisdiction_level.text, primary_contact_email.text, main_phone_number.text, website_url.text, established_date.date, parent_agency_id.text )\nCREATE TABLE government_services.applications ( application_id.text, citizen_id.text, service_id.text, submitted_at.timestamp, status.text, last_updated_at.timestamp, assigned_employee_id.text, decision_date.date, notes.text, reference_number.text )\nCREATE TABLE government_services.documents ( document_id.text, application_id.text, citizen_id.text, document_type.text, file_reference.text, upload_timestamp.timestamp, expiry_date.date, verification_status.text, verified_by_employee_id.text, verification_timestamp.timestamp )\nCREATE TABLE government_services.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 )\nCREATE TABLE government_services.appointments ( appointment_id.text, citizen_id.text, employee_id.text, location_id.text, service_id.text, scheduled_start_time.timestamp, scheduled_end_time.timestamp, purpose.text, status.text, booking_method.text, created_at.timestamp, notes.text )\n"}
{"conversations": [{"role": "user", "content": "Show me all transactions that occurred in the last week."}, {"role": "assistant", "content": "SELECT * FROM web3.transactions WHERE timestamp >= NOW() - INTERVAL '7 days';"}, {"role": "user", "content": "From that list, only show the ones with a status of 'failed'."}, {"role": "assistant", "content": "SELECT * FROM web3.transactions WHERE timestamp >= NOW() - INTERVAL '7 days' AND status = 'failed';"}], "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, 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 )\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": "Show me all active customers from California who were born before 1980, along with their contact information."}, {"role": "assistant", "content": "SELECT first_name, last_name, phone_number, email, address_line1, address_line2, city, state, zip_code FROM insurance.customers WHERE state = 'California' AND date_of_birth < '1980-01-01' AND status = 'Active';"}, {"role": "user", "content": "Now filter these results to only show customers who have provided both a phone number and an email address."}, {"role": "assistant", "content": "SELECT first_name, last_name, phone_number, email, address_line1, address_line2, city, state, zip_code FROM insurance.customers WHERE state = 'California' AND date_of_birth < '1980-01-01' AND status = 'Active' AND phone_number IS NOT NULL AND email IS NOT NULL;"}, {"role": "user", "content": "I also want to see how long these customers have been in our system (difference between current date and created_at in years)."}, {"role": "assistant", "content": "SELECT first_name, last_name, phone_number, email, address_line1, address_line2, city, state, zip_code, EXTRACT(YEAR FROM AGE(CURRENT_DATE, created_at)) AS years_in_system FROM insurance.customers WHERE state = 'California' AND date_of_birth < '1980-01-01' AND status = 'Active' AND phone_number IS NOT NULL AND email IS NOT NULL;"}, {"role": "user", "content": "Finally, order the results by the longest tenure in our system first, then by last name alphabetically."}, {"role": "assistant", "content": "SELECT first_name, last_name, phone_number, email, address_line1, address_line2, city, state, zip_code, EXTRACT(YEAR FROM AGE(CURRENT_DATE, created_at)) AS years_in_system FROM insurance.customers WHERE state = 'California' AND date_of_birth < '1980-01-01' AND status = 'Active' AND phone_number IS NOT NULL AND email IS NOT NULL ORDER BY years_in_system DESC, 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 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": "For each country code, what is the earliest registration date of a player?"}, {"role": "assistant", "content": "SELECT country_code, MIN(registration_date) AS earliest_reg_date FROM gaming_technology.players GROUP BY country_code;"}, {"role": "user", "content": "Only list countries where the earliest registration occurred before January 1st, 2020."}, {"role": "assistant", "content": "SELECT country_code, MIN(registration_date) AS earliest_reg_date FROM gaming_technology.players GROUP BY country_code HAVING MIN(registration_date) < '2020-01-01';"}, {"role": "user", "content": "Also include the total count of players for each of these countries."}, {"role": "assistant", "content": "SELECT country_code, MIN(registration_date) AS earliest_reg_date, COUNT(player_id) AS total_players FROM gaming_technology.players GROUP BY country_code HAVING MIN(registration_date) < '2020-01-01';"}, {"role": "user", "content": "Sort the results by the earliest registration date in ascending order."}, {"role": "assistant", "content": "SELECT country_code, MIN(registration_date) AS earliest_reg_date, COUNT(player_id) AS total_players FROM gaming_technology.players GROUP BY country_code HAVING MIN(registration_date) < '2020-01-01' ORDER BY earliest_reg_date ASC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.players ( player_id uuid PRIMARY KEY, username text, email text, password_hash text, registration_date timestamptz, last_login timestamptz, country_code text, status text, profile_data jsonb )\n"}
{"conversations": [{"role": "user", "content": "For each chain, which centralized exchange holds the largest total USD value in their token balance as of the most recent snapshot?"}, {"role": "assistant", "content": "WITH latest_snapshot AS (\n  SELECT MAX(snapshot_time) AS max_time FROM cex_token_balance\n)\nSELECT c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value\nFROM cex_token_balance c\nJOIN latest_snapshot l ON c.snapshot_time = l.max_time\nGROUP BY c.chain, c.exchange\nQUALIFY ROW_NUMBER() OVER(PARTITION BY c.chain ORDER BY SUM(c.usd_value) DESC) = 1;"}, {"role": "user", "content": "Could you also include the number of distinct tokens each exchange holds in those chains?"}, {"role": "assistant", "content": "WITH latest_snapshot AS (\n  SELECT MAX(snapshot_time) AS max_time FROM cex_token_balance\n),\nexchange_totals AS (\n  SELECT c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, COUNT(DISTINCT c.token_symbol) AS token_count\n  FROM cex_token_balance c\n  JOIN latest_snapshot l ON c.snapshot_time = l.max_time\n  GROUP BY c.chain, c.exchange\n),\nranked_exchanges AS (\n  SELECT *, ROW_NUMBER() OVER(PARTITION BY chain ORDER BY total_usd_value DESC) AS rn\n  FROM exchange_totals\n)\nSELECT chain, exchange, total_usd_value, token_count\nFROM ranked_exchanges\nWHERE rn = 1;"}, {"role": "user", "content": "I got an error with the QUALIFY clause. Can you rewrite the query using a derived table or CTE instead?"}, {"role": "assistant", "content": "WITH latest_snapshot AS (\n  SELECT MAX(snapshot_time) AS max_time FROM cex_token_balance\n),\nexchange_totals AS (\n  SELECT c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, COUNT(DISTINCT c.token_symbol) AS token_count\n  FROM cex_token_balance c\n  JOIN latest_snapshot l ON c.snapshot_time = l.max_time\n  GROUP BY c.chain, c.exchange\n),\nmax_values AS (\n  SELECT chain, MAX(total_usd_value) AS max_usd_value\n  FROM exchange_totals\n  GROUP BY chain\n)\nSELECT e.chain, e.exchange, e.total_usd_value, e.token_count\nFROM exchange_totals e\nJOIN max_values m ON e.chain = m.chain AND e.total_usd_value = m.max_usd_value;"}, {"role": "user", "content": "Now, only show exchanges where their usd_value is above $5,000,000."}, {"role": "assistant", "content": "WITH latest_snapshot AS (\n  SELECT MAX(snapshot_time) AS max_time FROM cex_token_balance\n),\nexchange_totals AS (\n  SELECT c.chain, c.exchange, SUM(c.usd_value) AS total_usd_value, COUNT(DISTINCT c.token_symbol) AS token_count\n  FROM cex_token_balance c\n  JOIN latest_snapshot l ON c.snapshot_time = l.max_time\n  GROUP BY c.chain, c.exchange\n),\nmax_values AS (\n  SELECT chain, MAX(total_usd_value) AS max_usd_value\n  FROM exchange_totals\n  GROUP BY chain\n)\nSELECT e.chain, e.exchange, e.total_usd_value, e.token_count\nFROM exchange_totals e\nJOIN max_values m ON e.chain = m.chain AND e.total_usd_value = m.max_usd_value\nWHERE e.total_usd_value > 5000000;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE project_fundraising_record ( id character varying(32) NOT NULL,  -- fundraising record id project_id character varying(32) NOT NULL, -- the invested project's id project_name character varying(128) NOT NULL, -- name of the invested project rounds_name character varying(32), -- name of the fundraising round investment_value numeric(38,14), -- amount of the fundraising in USD investment_date character varying(128), -- the date of the investment happened introduction character varying(128), -- the introduction of the invested project valuation numeric(38,14), -- the valuation of the project in USD when invested )\nCREATE TABLE token_basic_info ( coin_id character varying(100) NOT NULL, -- the id of the token token_name character varying(100) NOT NULL, -- the token's name token_symbol character varying(100) NOT NULL, -- the token's symbol token_address character varying(100) NOT NULL, -- the token's address chain text, -- the chain that the token resides price double precision, -- the current price of the token price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days highest_price_24h double precision, -- the highest price of the token in 24 hours lowest_price_24h double precision,  -- the lowest price of the token in 24 hours market_cap double precision, -- the market cap of the token market_cap_rank bigint, -- the rank of the token market cap in desc market_cap_change_percentage_24h text, -- the percentage of market cap changes in 24 hours total_volume text, -- the trade volum of the token both in decentralized exchange(DEX) and centralized exchange(CEX) narrative text, -- the category or narrative of the token trend_rank biging, -- the trending rank of the token, value 1 expresses the most popular token. ,PRIMARY KEY (coin_id, chain) )\nCREATE TABLE 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 character varying(32) NOT NULL,  -- the snapshot time of record, converted from original timestamp chain character varying(128) NOT NULL, -- the chain that the token resides address character varying(128) NOT NULL, -- the address that holds the assets, owned by a CEX exchange character varying(512) NOT NULL, -- a centralized exchange name token_address character varying(128) NOT NULL, -- token contract address token_symbol character varying(512), --token symbol balance numeric(38,10), -- token balance usd_value numeric(38,14), -- value of the token held in USD price double precision, --price of the token in USD ,PRIMARY KEY (snapshot_time, exchange, address, chain, token_address) )\nCREATE TABLE smart_money_profit ( address text, rank numeric, profit numeric, roi numeric, realized_ratio numeric, most_profit_token text, last_trade_time text, chain text )\n"}
{"conversations": [{"role": "user", "content": "List lawyers who have any unbilled time entries. Show their first name, last name, and the count of their unbilled entries."}, {"role": "assistant", "content": "SELECT T1.first_name, T1.last_name, COUNT(T2.entry_id) FROM lawyers AS T1 JOIN time_entries AS T2 ON T1.lawyer_id = T2.lawyer_id WHERE T2.is_billed = false GROUP BY T1.lawyer_id, T1.first_name, T1.last_name;"}, {"role": "user", "content": "Modify that query to only include entries marked as billable, and instead show the total hours spent rather than the count."}, {"role": "assistant", "content": "SELECT T1.first_name, T1.last_name, SUM(T2.hours_spent) FROM lawyers AS T1 JOIN time_entries AS T2 ON T1.lawyer_id = T2.lawyer_id WHERE T2.is_billed = false AND T2.is_billable = true GROUP BY T1.lawyer_id, T1.first_name, T1.last_name;"}, {"role": "user", "content": "Now, only show lawyers with more than 10 unbilled billable hours in total, and sort the results by the total hours descending."}, {"role": "assistant", "content": "SELECT T1.first_name, T1.last_name, SUM(T2.hours_spent) FROM lawyers AS T1 JOIN time_entries AS T2 ON T1.lawyer_id = T2.lawyer_id WHERE T2.is_billed = false AND T2.is_billable = true GROUP BY T1.lawyer_id, T1.first_name, T1.last_name HAVING SUM(T2.hours_spent) > 10 ORDER BY SUM(T2.hours_spent) DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE legal_services.lawyers ( lawyer_id text PRIMARY KEY, first_name text, last_name text, bar_number text UNIQUE, firm_id text, email text UNIQUE, phone text, specialization text, hire_date timestamp, is_partner bool )\nCREATE TABLE legal_services.law_firms ( firm_id text PRIMARY KEY, firm_name text, address text, phone text, website text, founded_date date, managing_partner_id text )\nCREATE TABLE legal_services.documents ( document_id text PRIMARY KEY, case_id text, document_name text, document_type text, storage_path text, uploaded_by_lawyer_id text, upload_timestamp timestamp, version int, description text )\nCREATE TABLE legal_services.time_entries ( entry_id text PRIMARY KEY, case_id text, lawyer_id text, date_worked date, hours_spent numeric, billing_rate numeric, description text, is_billable bool, is_billed bool, invoice_id text, created_at timestamp )\nCREATE TABLE legal_services.invoices ( invoice_id text PRIMARY KEY, invoice_number text UNIQUE, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )\nCREATE TABLE legal_services.appointments ( appointment_id text PRIMARY KEY, client_id text, lawyer_id text, case_id text, start_time timestamp, end_time timestamp, location text, subject text, notes text, status text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Display the name and type of each location, as well as the earliest and latest maintenance service_date for vehicles assigned to that location (assuming vehicle_id matches location_id)."}, {"role": "assistant", "content": "SELECT l.name, l.type,\n       MIN(m.service_date) AS earliest_service,\n       MAX(m.service_date) AS latest_service\nFROM transportation.locations l\nLEFT JOIN transportation.maintenance_logs m ON l.location_id = m.vehicle_id\nGROUP BY l.location_id, l.name, l.type;"}, {"role": "user", "content": "I got an error because some locations do not have any maintenance logs. Please only show locations that have at least one associated maintenance log."}, {"role": "assistant", "content": "SELECT l.name, l.type,\n       MIN(m.service_date) AS earliest_service,\n       MAX(m.service_date) AS latest_service\nFROM transportation.locations l\nJOIN transportation.maintenance_logs m ON l.location_id = m.vehicle_id\nGROUP BY l.location_id, l.name, l.type;"}, {"role": "user", "content": "Now, include the total cost of all maintenance performed for each location."}, {"role": "assistant", "content": "SELECT l.name, l.type,\n       MIN(m.service_date) AS earliest_service,\n       MAX(m.service_date) AS latest_service,\n       SUM(m.cost) AS total_maintenance_cost\nFROM transportation.locations l\nJOIN transportation.maintenance_logs m ON l.location_id = m.vehicle_id\nGROUP BY l.location_id, l.name, l.type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.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.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 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": "For each trip, show the trip ID, scheduled departure, and the last name of the driver."}, {"role": "assistant", "content": "SELECT t.trip_id, t.scheduled_departure, d.last_name\nFROM transportation.trips t\nJOIN transportation.drivers d ON t.driver_id = d.driver_id;"}, {"role": "user", "content": "I see some trip IDs are repeated. Only show distinct pairs of trip ID and driver last name."}, {"role": "assistant", "content": "SELECT DISTINCT t.trip_id, d.last_name\nFROM transportation.trips t\nJOIN transportation.drivers d ON t.driver_id = d.driver_id;"}, {"role": "user", "content": "Also, for these trips, include the name of the destination location."}, {"role": "assistant", "content": "SELECT DISTINCT t.trip_id, d.last_name, l.name AS destination_location_name\nFROM transportation.trips t\nJOIN transportation.drivers d ON t.driver_id = d.driver_id\nJOIN transportation.locations l ON t.destination_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.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.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 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.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 )\nCREATE TABLE transportation.bookings ( booking_id.text, passenger_id.text, trip_id.text, seat_number.text, booking_time.timestamp, status.text, fare.numeric, payment_transaction_id.text, special_requests.text )\n"}
{"conversations": [{"role": "user", "content": "List all users who have deployed contracts, along with their email addresses and the count of contracts they've deployed."}, {"role": "assistant", "content": "SELECT u.user_id, u.email, COUNT(c.contract_id) AS contract_count FROM web3.users u JOIN web3.contracts c ON u.user_id = c.deployer_address GROUP BY u.user_id, u.email;"}, {"role": "user", "content": "Actually, I only want to see users who have deployed more than 3 contracts."}, {"role": "assistant", "content": "SELECT u.user_id, u.email, COUNT(c.contract_id) AS contract_count FROM web3.users u JOIN web3.contracts c ON u.user_id = c.deployer_address GROUP BY u.user_id, u.email HAVING COUNT(c.contract_id) > 3;"}, {"role": "user", "content": "There's an error in your SQL, it should be 'deployer_address' not 'user_id' in the JOIN condition."}, {"role": "assistant", "content": "SELECT u.user_id, u.email, COUNT(c.contract_id) AS contract_count FROM web3.users u JOIN web3.contracts c ON u.user_id = c.deployer_address GROUP BY u.user_id, u.email HAVING COUNT(c.contract_id) > 3;"}, {"role": "user", "content": "Now sort the results by contract_count in descending order."}, {"role": "assistant", "content": "SELECT u.user_id, u.email, COUNT(c.contract_id) AS contract_count FROM web3.users u JOIN web3.contracts c ON u.user_id = c.deployer_address GROUP BY u.user_id, u.email HAVING COUNT(c.contract_id) > 3 ORDER BY contract_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 web3.contracts ( contract_id.text, address.text, abi.text, bytecode.text, deployer_address.text, deployed_at.timestamp, network_id.text, status.text )\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.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": "Show me the total USD value of tokens held by each centralized exchange on the 'Polygon' chain for the most recent snapshot time. List the exchange name and the total USD value."}, {"role": "assistant", "content": "WITH LatestSnapshot AS ( SELECT MAX(snapshot_time) as latest_time FROM cex_token_balance ) SELECT c.exchange, SUM(c.usd_value) as total_usd_value FROM cex_token_balance c JOIN LatestSnapshot ls ON c.snapshot_time = ls.latest_time WHERE c.chain = 'Polygon' GROUP BY c.exchange ORDER BY total_usd_value DESC;"}, {"role": "user", "content": "Can you also include the number of distinct token symbols held by each exchange in that chain and snapshot?"}, {"role": "assistant", "content": "WITH LatestSnapshot AS ( SELECT MAX(snapshot_time) as latest_time FROM cex_token_balance ) SELECT c.exchange, SUM(c.usd_value) as total_usd_value, COUNT(DISTINCT c.token_symbol) as distinct_token_count FROM cex_token_balance c JOIN LatestSnapshot ls ON c.snapshot_time = ls.latest_time WHERE c.chain = 'Polygon' GROUP BY c.exchange ORDER BY total_usd_value DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\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\n \"CREATE TABLE token_basic_info (\",\n    \"coin_id character varying(100) NOT NULL, -- the id of the token\",\n    \"token_name character varying(100) NOT NULL, -- the token's name\",\n    \"token_symbol character varying(100) NOT NULL, -- the token's symbol\",\n    \"token_address character varying(100) NOT NULL, -- the token's address\",\n    \"chain text, -- the chain that the token resides\",\n    \"price double precision, -- the current price of the token\",\n    \"price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour\",\n    \"price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours\",\n    \"price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days\",\n    \"highest_price_24h double precision, -- the highest price of the token in 24 hours\",\n    \"lowest_price_24h double precision,  -- the lowest price of the token in 24 hours\",\n    \"market_cap double precision, -- the market cap of the token\",\n    \"market_cap_rank bigint, -- the rank of the token market cap in desc\",\n    \"market_cap_change_percentage_24h text, -- the percentage of market cap changes in 24 hours\",\n    \"total_volume text, -- the trade volum of the token both in decentralized exchange(DEX) and centralized exchange(CEX)\",    \n    \"narrative text, -- the category or narrative of the token\",\n    \"trend_rank biging, -- the trending rank of the token, value 1 expresses the most popular token.\",\n    \",PRIMARY KEY (coin_id, chain));\",\n\n  \"CREATE TABLE token_dexpool_info (\",\n    \"pair_address character varying(512) NOT NULL, -- the id of dexpool\",\n    \"token_name character varying(100) NOT NULL, -- the name of the token in the dexpool\",\n    \"token_symbol character varying(100) NOT NULL, -- the token's symbol\",\n    \"chain text, -- the chain that the dexpool resides\",\n    \"price double precision, -- the current price of the token\",\n    \"price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour\",\n    \"price_change_percentage_6h double precision, -- change in value divided by the absolute price value of the original token price in 6 hours\",\n    \"price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours\",\n    \"makers_24h double precision, -- the makers of the dex pool in 24 hours\",\n    \"volume_24h double precision, -- the trade volume of the dex pool in 24 hours\",\n    \"liquidity double precision, -- the liquidity of the dex pool\",\n    \"market_cap double precision, -- the market cap of the token\",\n    \"trend_rank bigint, -- the rank of token in the dex pool of recent trending, value 1 expresses the most popular token.\",\n    \",PRIMARY KEY (pair_address, chain);\"\n\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  \"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": "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": "List all group conversations that were created after January 1st, 2023, and for each, show the names of hashtags that were created within the same month as the conversation."}, {"role": "assistant", "content": "SELECT c.conversation_id, c.group_name, c.created_at AS conversation_created_at, h.tag_name, h.created_at AS hashtag_created_at\nFROM social_media.conversations c\nJOIN social_media.hashtags h\n  ON DATE_TRUNC('month', c.created_at) = DATE_TRUNC('month', h.created_at)\nWHERE c.is_group_chat = TRUE\n  AND c.created_at > '2023-01-01';"}, {"role": "user", "content": "Instead of hashtag names, can you show their hashtag IDs?"}, {"role": "assistant", "content": "SELECT c.conversation_id, c.group_name, c.created_at AS conversation_created_at, h.hashtag_id, h.created_at AS hashtag_created_at\nFROM social_media.conversations c\nJOIN social_media.hashtags h\n  ON DATE_TRUNC('month', c.created_at) = DATE_TRUNC('month', h.created_at)\nWHERE c.is_group_chat = TRUE\n  AND c.created_at > '2023-01-01';"}, {"role": "user", "content": "Also, filter only group chats where the group name contains the word 'Project'."}, {"role": "assistant", "content": "SELECT c.conversation_id, c.group_name, c.created_at AS conversation_created_at, h.hashtag_id, h.created_at AS hashtag_created_at\nFROM social_media.conversations c\nJOIN social_media.hashtags h\n  ON DATE_TRUNC('month', c.created_at) = DATE_TRUNC('month', h.created_at)\nWHERE c.is_group_chat = TRUE\n  AND c.created_at > '2023-01-01'\n  AND c.group_name ILIKE '%Project%';"}], "system": "You are an SQL statement expert. Given the table structure 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.text, tag_name.text, created_at.timestamp )\nCREATE TABLE social_media.conversations ( conversation_id.text, created_at.timestamp, last_message_at.timestamp, is_group_chat.boolean, group_name.text )\n"}
{"conversations": [{"role": "user", "content": "List the IDs of citizens who have received notifications related to more than one distinct type of entity."}, {"role": "assistant", "content": "SELECT citizen_id FROM government_services.notifications WHERE related_entity_type IS NOT NULL AND related_entity_type != '' GROUP BY citizen_id HAVING COUNT(DISTINCT related_entity_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 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 first and last names of citizens who have submitted documents with a verification status of 'Rejected', along with the document type and application reference number."}, {"role": "assistant", "content": "SELECT c.first_name, c.last_name, d.document_type, a.reference_number FROM government_services.citizens AS c JOIN government_services.documents AS d ON c.citizen_id = d.citizen_id JOIN government_services.applications AS a ON d.application_id = a.application_id WHERE d.verification_status = 'Rejected';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id text, national_id_number text, first_name text, last_name text, date_of_birth date, gender text, primary_address text, contact_email text, contact_phone text, registration_date timestamp, is_verified boolean )\nCREATE TABLE government_services.agencies ( agency_id text, agency_name text, jurisdiction_level text, primary_contact_email text, main_phone_number text, website_url text, established_date date, parent_agency_id text )\nCREATE TABLE government_services.applications ( application_id text, citizen_id text, service_id text, submitted_at timestamp, status text, last_updated_at timestamp, assigned_employee_id text, decision_date date, notes text, reference_number text )\nCREATE TABLE government_services.documents ( document_id.text, application_id.text, citizen_id.text, document_type.text, file_reference.text, upload_timestamp.timestamp, expiry_date.date, verification_status.text, verified_by_employee_id.text, verification_timestamp.timestamp )\nCREATE TABLE government_services.payments ( payment_id text PRIMARY KEY, application_id text, citizen_id text, service_id text, amount numeric, currency text, payment_method text, payment_provider_reference text, payment_timestamp timestamp, status text, notes text )\nCREATE TABLE government_services.service_locations ( location_id 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.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 player, show the timestamp of their first achievement unlock. Include player_id and the timestamp."}, {"role": "assistant", "content": "SELECT player_id, MIN(unlocked_at) as first_unlock_at FROM gaming_technology.player_achievements GROUP BY player_id ORDER BY first_unlock_at;"}, {"role": "user", "content": "For each player, show the timestamp of their second earliest achievement unlock, if they have at least two. Include player_id and the timestamp."}, {"role": "assistant", "content": "WITH RankedUnlocks AS ( SELECT player_id, unlocked_at, ROW_NUMBER() OVER(PARTITION BY player_id ORDER BY unlocked_at) as rn FROM gaming_technology.player_achievements ) SELECT player_id, unlocked_at as second_unlock_at FROM RankedUnlocks WHERE rn = 2 ORDER BY player_id, second_unlock_at;"}, {"role": "user", "content": "List the player_id for players who unlocked their second achievement within 10 minutes of their first."}, {"role": "assistant", "content": "WITH PlayerFirstUnlock AS ( SELECT player_id, MIN(unlocked_at) as first_unlock_at FROM gaming_technology.player_achievements GROUP BY player_id ), RankedUnlocks AS ( SELECT player_id, unlocked_at, ROW_NUMBER() OVER(PARTITION BY player_id ORDER BY unlocked_at) as rn FROM gaming_technology.player_achievements ) SELECT pfu.player_id FROM PlayerFirstUnlock pfu JOIN RankedUnlocks ru ON pfu.player_id = ru.player_id WHERE ru.rn = 2 AND ru.unlocked_at <= pfu.first_unlock_at + INTERVAL '10 minute' ORDER BY pfu.player_id;"}, {"role": "user", "content": "For the players identified in the previous query (those whose second unlock was within 10 minutes of the first), list the achievement_id of their first and second unlocks."}, {"role": "assistant", "content": "WITH PlayerFirstUnlock AS ( SELECT player_id, MIN(unlocked_at) as first_unlock_at FROM gaming_technology.player_achievements GROUP BY player_id ), RankedUnlocks AS ( SELECT player_id, achievement_id, unlocked_at, ROW_NUMBER() OVER(PARTITION BY player_id ORDER BY unlocked_at) as rn FROM gaming_technology.player_achievements ), PlayersWithFastSecondUnlock AS ( SELECT pfu.player_id FROM PlayerFirstUnlock pfu JOIN RankedUnlocks ru ON pfu.player_id = ru.player_id WHERE ru.rn = 2 AND ru.unlocked_at <= pfu.first_unlock_at + INTERVAL '10 minute' ) SELECT pfl.player_id, ru_first.achievement_id as first_achievement_id, ru_second.achievement_id as second_achievement_id FROM PlayersWithFastSecondUnlock pfl JOIN RankedUnlocks ru_first ON pfl.player_id = ru_first.player_id AND ru_first.rn = 1 JOIN RankedUnlocks ru_second ON pfl.player_id = ru_second.player_id AND ru_second.rn = 2 ORDER BY pfl.player_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 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": "Which exchanges hold the largest total USD value of tokens on the BSC chain in the most recent snapshot, and what is the top token (by usd_value) held by each exchange?"}, {"role": "assistant", "content": "WITH latest_snapshot AS (\n  SELECT MAX(snapshot_time) AS max_time FROM cex_token_balance\n),\nexchange_totals AS (\n  SELECT \n    c.exchange, \n    SUM(c.usd_value) AS total_usd_value\n  FROM cex_token_balance c\n  JOIN latest_snapshot l ON c.snapshot_time = l.max_time\n  WHERE c.chain = 'BSC'\n  GROUP BY c.exchange\n),\ntop_token_per_exchange AS (\n  SELECT c.exchange, c.token_symbol, c.usd_value, ROW_NUMBER() OVER (PARTITION BY c.exchange ORDER BY c.usd_value DESC) AS rn\n  FROM cex_token_balance c\n  JOIN latest_snapshot l ON c.snapshot_time = l.max_time\n  WHERE c.chain = 'BSC'\n)\nSELECT \n  t.exchange, \n  e.total_usd_value, \n  t.token_symbol AS top_token_symbol, \n  t.usd_value AS top_token_usd_value\nFROM exchange_totals e\nJOIN top_token_per_exchange t ON e.exchange = t.exchange AND t.rn = 1\nORDER BY e.total_usd_value DESC;"}, {"role": "user", "content": "Can you add the number of distinct tokens each exchange holds on BSC in the latest snapshot to the result?"}, {"role": "assistant", "content": "WITH latest_snapshot AS (\n  SELECT MAX(snapshot_time) AS max_time FROM cex_token_balance\n),\nexchange_totals AS (\n  SELECT \n    c.exchange, \n    SUM(c.usd_value) AS total_usd_value,\n    COUNT(DISTINCT c.token_symbol) AS token_count\n  FROM cex_token_balance c\n  JOIN latest_snapshot l ON c.snapshot_time = l.max_time\n  WHERE c.chain = 'BSC'\n  GROUP BY c.exchange\n),\ntop_token_per_exchange AS (\n  SELECT c.exchange, c.token_symbol, c.usd_value, ROW_NUMBER() OVER (PARTITION BY c.exchange ORDER BY c.usd_value DESC) AS rn\n  FROM cex_token_balance c\n  JOIN latest_snapshot l ON c.snapshot_time = l.max_time\n  WHERE c.chain = 'BSC'\n)\nSELECT \n  t.exchange, \n  e.total_usd_value, \n  e.token_count,\n  t.token_symbol AS top_token_symbol, \n  t.usd_value AS top_token_usd_value\nFROM exchange_totals e\nJOIN top_token_per_exchange t ON e.exchange = t.exchange AND t.rn = 1\nORDER BY e.total_usd_value DESC;"}, {"role": "user", "content": "I'd like the results filtered so only exchanges holding more than $2,000,000 in total on BSC are included."}, {"role": "assistant", "content": "WITH latest_snapshot AS (\n  SELECT MAX(snapshot_time) AS max_time FROM cex_token_balance\n),\nexchange_totals AS (\n  SELECT \n    c.exchange, \n    SUM(c.usd_value) AS total_usd_value,\n    COUNT(DISTINCT c.token_symbol) AS token_count\n  FROM cex_token_balance c\n  JOIN latest_snapshot l ON c.snapshot_time = l.max_time\n  WHERE c.chain = 'BSC'\n  GROUP BY c.exchange\n  HAVING SUM(c.usd_value) > 2000000\n),\ntop_token_per_exchange AS (\n  SELECT c.exchange, c.token_symbol, c.usd_value, ROW_NUMBER() OVER (PARTITION BY c.exchange ORDER BY c.usd_value DESC) AS rn\n  FROM cex_token_balance c\n  JOIN latest_snapshot l ON c.snapshot_time = l.max_time\n  WHERE c.chain = 'BSC'\n)\nSELECT \n  t.exchange, \n  e.total_usd_value, \n  e.token_count,\n  t.token_symbol AS top_token_symbol, \n  t.usd_value AS top_token_usd_value\nFROM exchange_totals e\nJOIN top_token_per_exchange t ON e.exchange = t.exchange AND t.rn = 1\nORDER BY e.total_usd_value DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE cex_token_balance ( snapshot_time.text, chain.text, address.text, exchange.text, token_address.text, token_symbol.text, balance.numeric, usd_value.numeric, price.numeric )\n"}
{"conversations": [{"role": "user", "content": "I need a report of patients who have received prescriptions for medications manufactured by 'Pfizer'. Include patient ID, first name, last name, medication_name, and prescription_date."}, {"role": "assistant", "content": "SELECT p.patient_id,\n       p.first_name,\n       p.last_name,\n       m.medication_name,\n       pr.prescription_date\nFROM healthcare.patients AS p\nJOIN healthcare.prescriptions AS pr ON p.patient_id = pr.patient_id\nJOIN healthcare.medications AS m ON pr.medication_id = m.medication_id\nWHERE m.manufacturer = 'Pfizer';"}, {"role": "user", "content": "Actually, only include prescriptions with a dosage containing 'mg' and sort by prescription_date descending."}, {"role": "assistant", "content": "SELECT p.patient_id,\n       p.first_name,\n       p.last_name,\n       m.medication_name,\n       pr.prescription_date\nFROM healthcare.patients AS p\nJOIN healthcare.prescriptions AS pr ON p.patient_id = pr.patient_id\nJOIN healthcare.medications AS m ON pr.medication_id = m.medication_id\nWHERE m.manufacturer = 'Pfizer'\n  AND pr.dosage ILIKE '%mg%'\nORDER BY pr.prescription_date DESC;"}, {"role": "user", "content": "Also, include the patient's primary insurance policy number and plan name in the report."}, {"role": "assistant", "content": "SELECT p.patient_id,\n       p.first_name,\n       p.last_name,\n       m.medication_name,\n       pr.prescription_date,\n       pi.policy_number,\n       ip.plan_name\nFROM healthcare.patients AS p\nJOIN healthcare.prescriptions AS pr ON p.patient_id = pr.patient_id\nJOIN healthcare.medications AS m ON pr.medication_id = m.medication_id\nJOIN healthcare.patient_insurance AS pi\n  ON p.patient_id = pi.patient_id AND pi.is_primary = true\nJOIN healthcare.insurance_plans AS ip ON pi.plan_id = ip.plan_id\nWHERE m.manufacturer = 'Pfizer'\n  AND pr.dosage ILIKE '%mg%'\nORDER BY pr.prescription_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 ( 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.medical_records ( record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, appointment_id character varying(64) UNIQUE, doctor_id character varying(64) NOT NULL, record_date timestamp with time zone NOT NULL, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals jsonb, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (record_id) )\nCREATE TABLE healthcare.diagnoses ( diagnosis_id text PRIMARY KEY, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )\nCREATE TABLE healthcare.medications ( medication_id text, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )\nCREATE TABLE healthcare.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 character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, plan_id character varying(64) NOT NULL, policy_number character varying(100) NOT NULL, group_number character varying(100), subscriber_name character varying(200), effective_date date NOT NULL, expiration_date date, is_primary boolean NOT NULL DEFAULT true, PRIMARY KEY (patient_insurance_id), UNIQUE (patient_id, plan_id, policy_number) )\n"}
{"conversations": [{"role": "user", "content": "List all cancelled policies with their cancellation reasons and premium amounts."}, {"role": "assistant", "content": "SELECT policy_id, policy_number, cancellation_reason, premium_amount FROM insurance.policies WHERE status = 'Cancelled';"}, {"role": "user", "content": "Now show only policies that were cancelled within 3 months of their start date."}, {"role": "assistant", "content": "SELECT policy_id, policy_number, cancellation_reason, premium_amount, start_date, cancellation_date FROM insurance.policies WHERE status = 'Cancelled' AND cancellation_date <= start_date + INTERVAL '3 months';"}], "system": "You are an SQL statement expert. Given the table structure 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 (\n    policy_id character varying(64) NOT NULL, -- unique identifier for the policy\n    customer_id character varying(64) NOT NULL, -- identifier for the policyholder (FK to customers)\n    product_id character varying(64) NOT NULL, -- identifier for the insurance product (FK to insurance_products)\n    agent_id character varying(64), -- identifier for the agent who sold the policy (FK to agents)\n    policy_number character varying(100) NOT NULL UNIQUE, -- customer-facing policy number\n    start_date date NOT NULL, -- date the policy coverage begins\n    end_date date NOT NULL, -- date the policy coverage ends\n    premium_amount numeric(12, 2) NOT NULL, -- total premium for the policy term\n    coverage_limit numeric(15, 2) NOT NULL, -- maximum amount covered\n    deductible numeric(10, 2) NOT NULL, -- amount customer pays before coverage kicks in\n    status character varying(30) NOT NULL, -- e.g., Active, Expired, Cancelled, Pending\n    issued_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the policy was issued\n    cancellation_date date,\n    cancellation_reason text,\n    PRIMARY KEY (policy_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Find all blocks with difficulty above 5000 and include their timestamp."}, {"role": "assistant", "content": "SELECT block_id, timestamp FROM blockchain.blocks WHERE difficulty > 5000;"}, {"role": "user", "content": "Now show me the count of such blocks grouped by month in 2023."}, {"role": "assistant", "content": "SELECT DATE_TRUNC('month', timestamp) AS month, COUNT(*) AS block_count FROM blockchain.blocks WHERE difficulty > 5000 AND timestamp BETWEEN '2023-01-01' AND '2023-12-31' GROUP BY month ORDER BY month;"}, {"role": "user", "content": "Actually, I want to see the average difficulty for each of these months as well."}, {"role": "assistant", "content": "SELECT DATE_TRUNC('month', timestamp) AS month, COUNT(*) AS block_count, AVG(difficulty) AS avg_difficulty FROM blockchain.blocks WHERE difficulty > 5000 AND timestamp BETWEEN '2023-01-01' AND '2023-12-31' GROUP BY month ORDER BY month;"}, {"role": "user", "content": "Can you modify this to also include the block_id with the highest difficulty for each month?"}, {"role": "assistant", "content": "WITH monthly_stats AS (SELECT DATE_TRUNC('month', timestamp) AS month, COUNT(*) AS block_count, AVG(difficulty) AS avg_difficulty FROM blockchain.blocks WHERE difficulty > 5000 AND timestamp BETWEEN '2023-01-01' AND '2023-12-31' GROUP BY month) SELECT ms.month, ms.block_count, ms.avg_difficulty, (SELECT b.block_id FROM blockchain.blocks b WHERE DATE_TRUNC('month', b.timestamp) = ms.month AND b.difficulty > 5000 ORDER BY b.difficulty DESC LIMIT 1) AS highest_diff_block_id FROM monthly_stats ms ORDER BY ms.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 blockchain.blocks ( block_id text PRIMARY KEY, previous_block_id text, timestamp timestamp, nonce int, merkle_root text, difficulty int )\nCREATE TABLE blockchain.addresses ( address_id text PRIMARY KEY, public_key text, balance numeric )\nCREATE TABLE blockchain.smart_contracts ( contract_id text PRIMARY KEY, creator_address text, code text, timestamp timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show me all pairs of cases led by the same lawyer, including both case names and the lead lawyer ID."}, {"role": "assistant", "content": "SELECT c1.lead_lawyer_id,\n       c1.case_name AS case_name_1,\n       c2.case_name AS case_name_2\nFROM legal_services.cases c1\nJOIN legal_services.cases c2\n  ON c1.lead_lawyer_id = c2.lead_lawyer_id\n  AND c1.case_id < c2.case_id;"}, {"role": "user", "content": "Actually, only include pairs where the case types are also the same."}, {"role": "assistant", "content": "SELECT c1.lead_lawyer_id,\n       c1.case_name AS case_name_1,\n       c2.case_name AS case_name_2\nFROM legal_services.cases c1\nJOIN legal_services.cases c2\n  ON c1.lead_lawyer_id = c2.lead_lawyer_id\n  AND c1.case_type = c2.case_type\n  AND c1.case_id < c2.case_id;"}, {"role": "user", "content": "Also, show me the earliest opening date between the two cases for each pair."}, {"role": "assistant", "content": "SELECT c1.lead_lawyer_id,\n       c1.case_name AS case_name_1,\n       c2.case_name AS case_name_2,\n       LEAST(c1.date_opened, c2.date_opened) AS earliest_open_date\nFROM legal_services.cases c1\nJOIN legal_services.cases c2\n  ON c1.lead_lawyer_id = c2.lead_lawyer_id\n  AND c1.case_type = c2.case_type\n  AND c1.case_id < c2.case_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.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": "Show me all distinct dosage forms used in prescriptions."}, {"role": "assistant", "content": "SELECT DISTINCT dosage FROM healthcare.prescriptions;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.prescriptions ( prescription_id text PRIMARY KEY, 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 int, prescription_date timestamp )\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": "Show me the hashtag IDs and their names."}, {"role": "assistant", "content": "SELECT hashtag_id, tag_name FROM social_media.hashtags;"}, {"role": "user", "content": "I also want to see when each hashtag was created."}, {"role": "assistant", "content": "SELECT hashtag_id, tag_name, created_at FROM social_media.hashtags;"}, {"role": "user", "content": "Filter the list to only show hashtags whose name starts with the letter 'S'."}, {"role": "assistant", "content": "SELECT hashtag_id, tag_name, created_at FROM social_media.hashtags WHERE tag_name LIKE 'S%';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE social_media.hashtags ( hashtag_id character varying(64) NOT NULL, tag_name character varying(100) NOT NULL UNIQUE, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (hashtag_id) )\n"}
{"conversations": [{"role": "user", "content": "Can you write a query that retrieves each server's name, its region, and the highest current player count observed in that region?"}, {"role": "assistant", "content": "SELECT s.server_name, s.region, m.max_current_players\nFROM gaming_technology.servers s\nJOIN (\n  SELECT region, MAX(current_players) AS max_current_players\n  FROM gaming_technology.servers\n  GROUP BY region\n) m ON s.region = m.region;"}, {"role": "user", "content": "Actually, only include regions where that maximum current player count exceeds 50."}, {"role": "assistant", "content": "SELECT s.server_name, s.region, m.max_current_players\nFROM gaming_technology.servers s\nJOIN (\n  SELECT region, MAX(current_players) AS max_current_players\n  FROM gaming_technology.servers\n  GROUP BY region\n  HAVING MAX(current_players) > 50\n) m ON s.region = m.region;"}, {"role": "user", "content": "Also, exclude any servers that are already full (where current_players equals max_players)."}, {"role": "assistant", "content": "SELECT s.server_name, s.region, m.max_current_players\nFROM gaming_technology.servers s\nJOIN (\n  SELECT region, MAX(current_players) AS max_current_players\n  FROM gaming_technology.servers\n  GROUP BY region\n  HAVING MAX(current_players) > 50\n) m ON s.region = m.region\nWHERE s.current_players < s.max_players;"}, {"role": "user", "content": "Finally, sort the results by region ascending and then by the maximum current players in descending order."}, {"role": "assistant", "content": "SELECT s.server_name, s.region, m.max_current_players\nFROM gaming_technology.servers s\nJOIN (\n  SELECT region, MAX(current_players) AS max_current_players\n  FROM gaming_technology.servers\n  GROUP BY region\n  HAVING MAX(current_players) > 50\n) m ON s.region = m.region\nWHERE s.current_players < s.max_players\nORDER BY s.region ASC, m.max_current_players DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE gaming_technology.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) )\n"}
{"conversations": [{"role": "user", "content": "List the vehicle_id, make, model, and total maintenance cost for each vehicle that has undergone maintenance, ordering by total maintenance cost descending."}, {"role": "assistant", "content": "SELECT m.vehicle_id, v.make, v.model, SUM(m.cost) AS total_maintenance_cost\nFROM transportation.maintenance_logs m\nJOIN transportation.vehicles v ON m.vehicle_id = v.vehicle_id\nGROUP BY m.vehicle_id, v.make, v.model\nORDER BY total_maintenance_cost DESC;"}, {"role": "user", "content": "Now further include the count of maintenance entries per vehicle and only include vehicles with more than 3 maintenance logs."}, {"role": "assistant", "content": "SELECT m.vehicle_id, v.make, v.model, COUNT(*) AS maintenance_count, SUM(m.cost) AS total_maintenance_cost\nFROM transportation.maintenance_logs m\nJOIN transportation.vehicles v ON m.vehicle_id = v.vehicle_id\nGROUP BY m.vehicle_id, v.make, v.model\nHAVING COUNT(*) > 3\nORDER BY total_maintenance_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 ( 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, route_id.text, vehicle_id.text, driver_id.text, scheduled_departure.timestamp, actual_departure.timestamp, scheduled_arrival.timestamp, actual_arrival.timestamp, origin_location_id.text, destination_location_id.text, status.text, passenger_count.integer, cargo_manifest_id.text )\nCREATE TABLE transportation.maintenance_logs ( log_id text, vehicle_id text, service_date date, odometer_reading integer, service_type text, description text, cost numeric, mechanic_name text, next_service_due_date date )\nCREATE TABLE transportation.fuel_logs ( fuel_log_id.text, vehicle_id.text, trip_id.text, log_timestamp.timestamp, fuel_type.text, quantity.numeric, unit.text, cost_per_unit.numeric, total_cost.numeric, odometer_reading.integer, location_id.text )\nCREATE TABLE transportation.passengers ( passenger_id text PRIMARY KEY, 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": "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 the name, description, and URL for all DApps."}, {"role": "assistant", "content": "SELECT name, description, url FROM trading_platform.dapps;"}], "system": "You are an SQL statement expert. Given the table structure 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.dapps (\n    dapp_id character varying(64) NOT NULL,  -- unique identifier for the DApp\n    name character varying(128) NOT NULL, -- name of the DApp\n    description text NOT NULL, -- description of the DApp\n    url character varying(256) NOT NULL, -- URL of the DApp\n    PRIMARY KEY (dapp_id)\n)\nCREATE TABLE trading_platform.metadata (\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)\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 fundraising round in 2022 and 2023, list the round name, the year, the total investment_value, and the count of distinct projects. Also include the average market_cap of associated tokens by matching project_name to token_symbol in token_basic_info."}, {"role": "assistant", "content": "SELECT p.rounds_name,\n  SUBSTRING(p.investment_date FROM 1 FOR 4) AS year,\n  SUM(p.investment_value) AS total_investment,\n  COUNT(DISTINCT p.project_id) AS project_count,\n  AVG(t.market_cap) AS avg_market_cap\nFROM project_fundraising_record p\nJOIN token_basic_info t\n  ON LOWER(p.project_name) = LOWER(t.token_symbol)\nWHERE SUBSTRING(p.investment_date FROM 1 FOR 4) IN ('2022','2023')\nGROUP BY p.rounds_name, SUBSTRING(p.investment_date FROM 1 FOR 4);"}, {"role": "user", "content": "The join returns no rows. Please change the join to match when token_symbol is contained within project_name, case-insensitive."}, {"role": "assistant", "content": "SELECT p.rounds_name,\n  SUBSTRING(p.investment_date FROM 1 FOR 4) AS year,\n  SUM(p.investment_value) AS total_investment,\n  COUNT(DISTINCT p.project_id) AS project_count,\n  AVG(t.market_cap) AS avg_market_cap\nFROM project_fundraising_record p\nJOIN token_basic_info t\n  ON LOWER(p.project_name) LIKE '%' || LOWER(t.token_symbol) || '%'\nWHERE SUBSTRING(p.investment_date FROM 1 FOR 4) IN ('2022','2023')\nGROUP BY p.rounds_name, SUBSTRING(p.investment_date FROM 1 FOR 4);"}, {"role": "user", "content": "Now only include rounds where the total investment_value exceeds 5000000."}, {"role": "assistant", "content": "SELECT p.rounds_name,\n  SUBSTRING(p.investment_date FROM 1 FOR 4) AS year,\n  SUM(p.investment_value) AS total_investment,\n  COUNT(DISTINCT p.project_id) AS project_count,\n  AVG(t.market_cap) AS avg_market_cap\nFROM project_fundraising_record p\nJOIN token_basic_info t\n  ON LOWER(p.project_name) LIKE '%' || LOWER(t.token_symbol) || '%'\nWHERE SUBSTRING(p.investment_date FROM 1 FOR 4) IN ('2022','2023')\nGROUP BY p.rounds_name, SUBSTRING(p.investment_date FROM 1 FOR 4)\nHAVING SUM(p.investment_value) > 5000000;"}, {"role": "user", "content": "Finally, order the results by total_investment descending."}, {"role": "assistant", "content": "SELECT p.rounds_name,\n  SUBSTRING(p.investment_date FROM 1 FOR 4) AS year,\n  SUM(p.investment_value) AS total_investment,\n  COUNT(DISTINCT p.project_id) AS project_count,\n  AVG(t.market_cap) AS avg_market_cap\nFROM project_fundraising_record p\nJOIN token_basic_info t\n  ON LOWER(p.project_name) LIKE '%' || LOWER(t.token_symbol) || '%'\nWHERE SUBSTRING(p.investment_date FROM 1 FOR 4) IN ('2022','2023')\nGROUP BY p.rounds_name, SUBSTRING(p.investment_date FROM 1 FOR 4)\nHAVING SUM(p.investment_value) > 5000000\nORDER BY total_investment DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE project_fundraising_record ( id character varying(32) NOT NULL, project_id character varying(32) NOT NULL, project_name character varying(128) NOT NULL, rounds_name character varying(32), investment_value numeric(38,14), investment_date character varying(128), introduction character varying(128), valuation numeric(38,14) )\nCREATE TABLE token_basic_info ( coin_id text, token_name text, token_symbol text, token_address text, chain text, price numeric, price_change_percentage_1h numeric, price_change_percentage_24h numeric, price_change_percentage_7d numeric, highest_price_24h numeric, lowest_price_24h numeric, market_cap numeric, market_cap_rank numeric, market_cap_change_percentage_24h text, total_volume text, narrative text, trend_rank numeric )\n \"CREATE TABLE narrative_info (\",\n    \"narrative character varying(512) NOT NULL, -- the id of narrative\",\n    \"top_3_coins text, -- the top 3 tokens in the narrative\",\n    \"price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour in the narrative\",\n    \"price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours in the narrative\",\n    \"price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days in the narrative\",\n    \"market_cap double precision, -- the market cap of the narrative\",\n    \"volume_24h double precision, -- the trade volume of the narrative\",\n    \"trend_rank bigint, -- the trending rank of the narrative, value 1 expresses the most popular narrative\",\n    \"token_num bigint, -- total token number in the narrative\",\n    \",PRIMARY KEY (narrative));\"\n\nCREATE TABLE token_dexpool_info ( pair_address character varying(512) NOT NULL, -- the id of dexpool token_name character varying(100) NOT NULL, -- the name of the token in the dexpool token_symbol character varying(100) NOT NULL, -- the token's symbol chain text, -- the chain that the dexpool resides price double precision, -- the current price of the token price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour price_change_percentage_6h double precision, -- change in value divided by the absolute price value of the original token price in 6 hours price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours makers_24h double precision, -- the makers of the dex pool in 24 hours volume_24h double precision, -- the trade volume of the dex pool in 24 hours liquidity double precision, -- the liquidity of the dex pool market_cap double precision, -- the market cap of the token trend_rank bigint, -- the rank of token in the dex pool of recent trending, value 1 expresses the most popular token. ,PRIMARY KEY (pair_address, chain) )\n  \"CREATE TABLE cex_token_balance (\",\n    \"snapshot_time character varying(32) NOT NULL,  -- the snapshot time of record, converted from original timestamp\",\n    \"chain character varying(128) NOT NULL, -- the chain that the token resides\",\n    \"address character varying(128) NOT NULL, -- the address that holds the assets, owned by a CEX\",\n    \"exchange character varying(512) NOT NULL, -- a centralized exchange name\",\n    \"token_address character varying(128) NOT NULL, -- token contract address\",\n    \"token_symbol character varying(512), --token symbol\",\n    \"balance numeric(38,10), -- token balance\",\n    \"usd_value numeric(38,14), -- value of the token held in USD\",\n    \"price double precision, --price of the token in USD\",\n    \",PRIMARY KEY (snapshot_time, exchange, address, chain, token_address));\"\n\nCREATE TABLE smart_money_token_performance ( token_address text, token_symbol text, pnl numeric, net_flow numeric, avg_cost numeric, price numeric, realized_ratio numeric, roi numeric, chain text )\nCREATE TABLE smart_money_token_inflow ( token_address text, token_symbol text, token_amount numeric, usd_value numeric, avg_price numeric, type numeric, address_amount numeric, narrative text, chain text )\n"}
{"conversations": [{"role": "user", "content": "Show me the names and URLs of all DApps where the description contains the word 'wallet'."}, {"role": "assistant", "content": "SELECT name, url FROM trading_platform.dapps WHERE description ILIKE '%wallet%';"}, {"role": "user", "content": "I also want to see their dapp_id included in the result."}, {"role": "assistant", "content": "SELECT dapp_id, name, url FROM trading_platform.dapps WHERE description ILIKE '%wallet%';"}], "system": "You are an SQL statement expert. Given the table structure 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.dapps ( dapp_id.text, name.text, description.text, url.text )\n"}
{"conversations": [{"role": "user", "content": "List all guests who have made at least one reservation. Show their first and last names and the number of reservations they have made."}, {"role": "assistant", "content": "SELECT g.first_name, g.last_name, COUNT(r.reservation_id) AS reservation_count\nFROM hospitality_technology.guests g\nJOIN hospitality_technology.reservations r ON g.guest_id = r.guest_id\nGROUP BY g.guest_id, g.first_name, g.last_name;"}, {"role": "user", "content": "Show only the guests who made 3 or more reservations and order by reservation_count descending."}, {"role": "assistant", "content": "SELECT g.first_name, g.last_name, COUNT(r.reservation_id) AS reservation_count\nFROM hospitality_technology.guests g\nJOIN hospitality_technology.reservations r ON g.guest_id = r.guest_id\nGROUP BY g.guest_id, g.first_name, g.last_name\nHAVING COUNT(r.reservation_id) >= 3\nORDER BY reservation_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.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.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) )\n"}
{"conversations": [{"role": "user", "content": "Show me all reservations with their guest IDs and room IDs where the total amount is greater than $500 and the status is 'Confirmed', ordered by check-in date."}, {"role": "assistant", "content": "SELECT reservation_id, guest_id, room_id, check_in_date, total_amount FROM hospitality_technology.reservations WHERE total_amount > 500 AND status = 'Confirmed' ORDER BY check_in_date;"}, {"role": "user", "content": "Now, join this with the service_orders table to include the total price of all services ordered for each reservation."}, {"role": "assistant", "content": "SELECT r.reservation_id, r.guest_id, r.room_id, r.check_in_date, r.total_amount, SUM(so.total_price) AS total_service_price FROM hospitality_technology.reservations r LEFT JOIN hospitality_technology.service_orders so ON r.reservation_id = so.reservation_id WHERE r.total_amount > 500 AND r.status = 'Confirmed' GROUP BY r.reservation_id, r.guest_id, r.room_id, r.check_in_date, r.total_amount ORDER BY r.check_in_date;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.reservations ( reservation_id.text, property_id.text, guest_id.text, room_id.text, room_type_id.text, check_in_date.date, check_out_date.date, actual_check_in_ts.timestamp, actual_check_out_ts.timestamp, num_adults.integer, num_children.integer, status.text, booking_source.text, rate_plan_id.text, total_amount.numeric, amount_paid.numeric, special_requests.text, created_at.timestamp, updated_at.timestamp )\nCREATE TABLE hospitality_technology.service_orders ( order_id character varying(64) NOT NULL, reservation_id character varying(64), guest_id character varying(64) NOT NULL, service_id character varying(64) NOT NULL, staff_id_ordered character varying(64), staff_id_delivered character varying(64), order_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, delivery_timestamp timestamp with time zone, quantity integer NOT NULL DEFAULT 1, unit_price numeric(10, 2) NOT NULL, total_price numeric(12, 2) NOT NULL, status character varying(50) NOT NULL, notes text, bill_id character varying(64), PRIMARY KEY (order_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (service_id) REFERENCES hospitality_technology.services(service_id), FOREIGN KEY (staff_id_ordered) REFERENCES hospitality_technology.staff(staff_id), FOREIGN KEY (staff_id_delivered) REFERENCES hospitality_technology.staff(staff_id) )\nCREATE TABLE hospitality_technology.reviews ( review_id character varying(64) NOT NULL, property_id character varying(64) NOT NULL, reservation_id character varying(64) UNIQUE, guest_id character varying(64) NOT NULL, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source character varying(100), review_date timestamp with time zone NOT NULL DEFAULT current_timestamp, is_public boolean DEFAULT true, staff_response text, response_staff_id character varying(64), response_date timestamp with time zone, PRIMARY KEY (review_id), FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id), FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id), FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id), FOREIGN KEY (response_staff_id) REFERENCES hospitality_technology.staff(staff_id) )\n"}
{"conversations": [{"role": "user", "content": "Show me all SUI coins with a balance greater than 1000, including their symbol and name."}, {"role": "assistant", "content": "SELECT sc.object_id, sc.coin_type, sc.balance, scm.symbol, scm.name FROM sui_coins sc JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type WHERE CAST(sc.balance AS DECIMAL) > 1000;"}, {"role": "user", "content": "Also, include the owner address for each coin in the result."}, {"role": "assistant", "content": "SELECT sc.object_id, sc.coin_type, sc.balance, sc.owner, scm.symbol, scm.name FROM sui_coins sc JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type WHERE CAST(sc.balance AS DECIMAL) > 1000;"}, {"role": "user", "content": "Only show coins which are currently 'active', and add the coin description."}, {"role": "assistant", "content": "SELECT sc.object_id, sc.coin_type, sc.balance, sc.owner, scm.symbol, scm.name, scm.description FROM sui_coins sc JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type WHERE CAST(sc.balance AS DECIMAL) > 1000 AND sc.status = 'active' AND scm.status = 'active';"}, {"role": "user", "content": "Actually, limit the result to just 10 coins and sort them by balance descending."}, {"role": "assistant", "content": "SELECT sc.object_id, sc.coin_type, sc.balance, sc.owner, scm.symbol, scm.name, scm.description FROM sui_coins sc JOIN sui_coins_metadata scm ON sc.coin_type = scm.coin_type WHERE CAST(sc.balance AS DECIMAL) > 1000 AND sc.status = 'active' AND scm.status = 'active' ORDER BY CAST(sc.balance AS DECIMAL) 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 erc20_balances ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk varchar )\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk integer )\nCREATE TABLE nft_holder_historical ( block_number bigint, contract_address varchar, wallet_address varchar, token_id varchar, contract_type varchar, amount varchar, pk integer )\nCREATE TABLE sui_coins ( object_id varchar, status varchar, coin_type varchar, balance varchar, owner varchar )\nCREATE TABLE sui_coins_metadata ( object_id varchar, coin_type varchar, status varchar, decimals bigint, description varchar, icon_url varchar, symbol varchar, name varchar )\nCREATE TABLE nft_metadata ( blockchain varchar, contract_address varchar, token_id varchar, contract_name varchar, erc_type varchar, amount bigint, minter varchar, owner varchar, mint_block_number bigint, mint_time bigint, mint_transaction_hash varchar, mint_price varchar, token_uri varchar, metadata varchar, name varchar, image_uri varchar, traits varchar, updated_at bigint, status varchar, rarity_score real, rarity_rank integer, unique_attribute_count integer, pk integer )\nCREATE TABLE nft_collections ( blockchain varchar, contract_address varchar, name varchar, symbol varchar, deploy_block_number bigint, deploy_block_time bigint, erc_type varchar, owner varchar, traits varchar, description varchar, slug varchar, media_info varchar, image_url varchar, banner_image_url varchar, updated_at bigint, banner varchar, token_count bigint, floor_price varchar, floor_price_symbol varchar, floor_price_contract varchar, pk integer )\nCREATE TABLE token_prices_latest ( blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash varchar, log_index integer, contract_address varchar, pk integer )\nCREATE TABLE token_activities ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash varchar, log_index integer, type varchar, tick varchar, id varchar, amt decimal, from_address varchar, to_address varchar )\nCREATE TABLE mud_holesky_redstone ( address varchar, table_id varchar, key_bytes varchar, key0 varchar, key1 varchar, static_data varchar, encoded_lengths varchar, dynamic_data varchar, is_deleted boolean, block_number bigint, log_index bigint )\nCREATE TABLE token_info_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash varchar, tick varchar, max_supply decimal, lim decimal, wlim decimal, dec integer, creator varchar )\nCREATE TABLE token_info_avalanche ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash varchar, tick varchar, max_supply decimal, lim decimal, wlim decimal, dec integer, creator varchar, minted decimal, holders decimal, txs decimal, updated_timestamp timestamp, completed_timestamp timestamp, id varchar )\n"}
{"conversations": [{"role": "user", "content": "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": "For each case type, calculate the average time to close cases in days, only including cases that have been closed."}, {"role": "assistant", "content": "SELECT case_type,\n       AVG(EXTRACT(EPOCH FROM (date_closed - date_opened)) / 86400) AS avg_close_days\nFROM legal_services.cases\nWHERE status = 'Closed'\n  AND date_closed IS NOT NULL\nGROUP BY case_type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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": "How many unique tokens are recorded for each chain in the latest snapshot in cex_token_balance?"}, {"role": "assistant", "content": "WITH latest_snapshot AS (\n  SELECT MAX(snapshot_time) AS max_time FROM cex_token_balance\n)\nSELECT \n  chain, \n  COUNT(DISTINCT token_symbol) AS unique_token_count\nFROM cex_token_balance c\nJOIN latest_snapshot l ON c.snapshot_time = l.max_time\nGROUP BY chain\nORDER BY unique_token_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 cex_token_balance ( snapshot_time.text, chain.text, address.text, exchange.text, token_address.text, token_symbol.text, balance.numeric, usd_value.numeric, price.numeric )\n"}
{"conversations": [{"role": "user", "content": "List all orders, showing order ID, type, quantity, and the asset name."}, {"role": "assistant", "content": "SELECT o.order_id, o.order_type, o.quantity, a.name FROM trading_platform.orders o JOIN trading_platform.assets a ON o.asset_id = a.asset_id;"}, {"role": "user", "content": "Now, only include orders with 'completed' status and a quantity greater than 10."}, {"role": "assistant", "content": "SELECT o.order_id, o.order_type, o.quantity, a.name FROM trading_platform.orders o JOIN trading_platform.assets a ON o.asset_id = a.asset_id WHERE o.status = 'completed' AND o.quantity > 10;"}, {"role": "user", "content": "Actually, I also want to see the user ID of the user who placed the order."}, {"role": "assistant", "content": "SELECT o.order_id, o.order_type, o.quantity, a.name, w.user_id FROM trading_platform.orders o JOIN trading_platform.assets a ON o.asset_id = a.asset_id JOIN trading_platform.wallets w ON o.wallet_id = w.wallet_id WHERE o.status = 'completed' AND o.quantity > 10;"}, {"role": "user", "content": "The previous query didn't work because some completed orders might not be linked to a wallet? Can you show the order ID, type, quantity, asset name, but also include the user ID if available through the wallet linkage, and still filter by 'completed' status and quantity > 10?"}, {"role": "assistant", "content": "SELECT o.order_id, o.order_type, o.quantity, a.name, w.user_id FROM trading_platform.orders o JOIN trading_platform.assets a ON o.asset_id = a.asset_id LEFT JOIN trading_platform.wallets w ON o.wallet_id = w.wallet_id WHERE o.status = 'completed' AND o.quantity > 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 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 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.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 text, asset_id text, key text, value text )\nCREATE TABLE trading_platform.logs ( log_id text, user_id text, action text, details text, logged_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Get the number of documents for each case, showing case_id and document count, ordered by count descending."}, {"role": "assistant", "content": "SELECT case_id,\n       COUNT(*) AS document_count\nFROM legal_services.documents\nGROUP BY case_id\nORDER BY document_count DESC;"}, {"role": "user", "content": "Actually, only count documents of type 'Evidence'."}, {"role": "assistant", "content": "SELECT case_id,\n       COUNT(*) AS evidence_count\nFROM legal_services.documents\nWHERE document_type = 'Evidence'\nGROUP BY case_id\nORDER BY evidence_count DESC;"}, {"role": "user", "content": "Also, include the case_name from the cases table."}, {"role": "assistant", "content": "SELECT d.case_id,\n       c.case_name,\n       COUNT(*) AS evidence_count\nFROM legal_services.documents d\nJOIN legal_services.cases c ON d.case_id = c.case_id\nWHERE d.document_type = 'Evidence'\nGROUP BY d.case_id, c.case_name\nORDER BY evidence_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.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.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 )\nCREATE TABLE legal_services.time_entries ( entry_id text PRIMARY KEY, case_id text, lawyer_id text, date_worked date, hours_spent numeric, billing_rate numeric, description text, is_billable bool, is_billed bool, invoice_id text, created_at timestamp )\nCREATE TABLE legal_services.invoices ( invoice_id text PRIMARY KEY, invoice_number text UNIQUE, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Find all smart contracts where the code length is greater than 1000 characters."}, {"role": "assistant", "content": "SELECT contract_id, creator_address, LENGTH(code) AS code_length FROM blockchain.smart_contracts WHERE LENGTH(code) > 1000;"}, {"role": "user", "content": "Now group these by creator_address and show the count of such contracts per creator."}, {"role": "assistant", "content": "SELECT creator_address, COUNT(*) AS large_code_contract_count FROM blockchain.smart_contracts WHERE LENGTH(code) > 1000 GROUP BY creator_address;"}, {"role": "user", "content": "Can you order the results by the count in descending order?"}, {"role": "assistant", "content": "SELECT creator_address, COUNT(*) AS large_code_contract_count FROM blockchain.smart_contracts WHERE LENGTH(code) > 1000 GROUP BY creator_address ORDER BY large_code_contract_count DESC;"}, {"role": "user", "content": "Now show only creators who have more than 3 such contracts."}, {"role": "assistant", "content": "SELECT creator_address, COUNT(*) AS large_code_contract_count FROM blockchain.smart_contracts WHERE LENGTH(code) > 1000 GROUP BY creator_address HAVING COUNT(*) > 3 ORDER BY large_code_contract_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE blockchain.smart_contracts ( contract_id.text, creator_address.text, code.text, timestamp.timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show the number of reservations and the sum total_amount for each property."}, {"role": "assistant", "content": "SELECT p.property_id, p.property_name, COUNT(r.reservation_id) AS reservation_count, SUM(r.total_amount) AS total_revenue \nFROM hospitality_technology.properties p \nLEFT JOIN hospitality_technology.reservations r ON p.property_id = r.property_id \nGROUP BY p.property_id, p.property_name;"}, {"role": "user", "content": "Return only those properties with at least 50 reservations."}, {"role": "assistant", "content": "SELECT p.property_id, p.property_name, COUNT(r.reservation_id) AS reservation_count, SUM(r.total_amount) AS total_revenue \nFROM hospitality_technology.properties p \nLEFT JOIN hospitality_technology.reservations r ON p.property_id = r.property_id \nGROUP BY p.property_id, p.property_name \nHAVING COUNT(r.reservation_id) >= 50;"}, {"role": "user", "content": "Additionally, only include properties in cities that start with the letter 'S' and order by total revenue descending."}, {"role": "assistant", "content": "SELECT p.property_id, p.property_name, COUNT(r.reservation_id) AS reservation_count, SUM(r.total_amount) AS total_revenue \nFROM hospitality_technology.properties p \nLEFT JOIN hospitality_technology.reservations r ON p.property_id = r.property_id \nWHERE p.city LIKE 'S%'\nGROUP BY p.property_id, p.property_name \nHAVING COUNT(r.reservation_id) >= 50\nORDER BY total_revenue DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.properties ( property_id text, 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.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 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.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": "What is the average number of wallets each user owns?"}, {"role": "assistant", "content": "SELECT\n  AVG(wallet_count) AS avg_wallets_per_user\nFROM (\n  SELECT user_id, COUNT(*) AS wallet_count\n  FROM web3.wallets\n  GROUP BY user_id\n) AS sub;"}, {"role": "user", "content": "Actually, calculate the average only for users who own more than one wallet."}, {"role": "assistant", "content": "SELECT\n  AVG(wallet_count) AS avg_wallets_per_user\nFROM (\n  SELECT user_id, COUNT(*) AS wallet_count\n  FROM web3.wallets\n  GROUP BY user_id\n  HAVING COUNT(*) > 1\n) AS sub;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.wallets ( wallet_id text PRIMARY KEY, user_id text, address text, private_key text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Get a list of all policies that have at least two beneficiaries with a percentage_share greater than 20%. Include policy_id, policy_number, and beneficiary_count."}, {"role": "assistant", "content": "SELECT p.policy_id, p.policy_number, COUNT(pb.beneficiary_id) AS beneficiary_count\nFROM insurance.policies p\nJOIN insurance.policy_beneficiaries pb\n  ON p.policy_id = pb.policy_id\nWHERE pb.percentage_share > 20\nGROUP BY p.policy_id, p.policy_number\nHAVING COUNT(pb.beneficiary_id) >= 2;"}, {"role": "user", "content": "Also include the names of those beneficiaries concatenated as a comma-separated string labeled beneficiaries."}, {"role": "assistant", "content": "SELECT p.policy_id, p.policy_number,\n       COUNT(pb.beneficiary_id) AS beneficiary_count,\n       STRING_AGG(pb.first_name || ' ' || pb.last_name, ', ') AS beneficiaries\nFROM insurance.policies p\nJOIN insurance.policy_beneficiaries pb\n  ON p.policy_id = pb.policy_id\nWHERE pb.percentage_share > 20\nGROUP BY p.policy_id, p.policy_number\nHAVING COUNT(pb.beneficiary_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 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 (\n    policy_id character varying(64) NOT NULL, -- unique identifier for the policy\n    customer_id character varying(64) NOT NULL, -- identifier for the policyholder (FK to customers)\n    product_id character varying(64) NOT NULL, -- identifier for the insurance product (FK to insurance_products)\n    agent_id character varying(64), -- identifier for the agent who sold the policy (FK to agents)\n    policy_number character varying(100) NOT NULL UNIQUE, -- customer-facing policy number\n    start_date date NOT NULL, -- date the policy coverage begins\n    end_date date NOT NULL, -- date the policy coverage ends\n    premium_amount numeric(12, 2) NOT NULL, -- total premium for the policy term\n    coverage_limit numeric(15, 2) NOT NULL, -- maximum amount covered\n    deductible numeric(10, 2) NOT NULL, -- amount customer pays before coverage kicks in\n    status character varying(30) NOT NULL, -- e.g., Active, Expired, Cancelled, Pending\n    issued_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the policy was issued\n    cancellation_date date,\n    cancellation_reason text,\n    PRIMARY KEY (policy_id)\n)\nCREATE TABLE insurance.claims ( 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.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.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.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 me all room types with a base rate over $200 and max occupancy of at least 4, along with their property IDs and amenities."}, {"role": "assistant", "content": "SELECT room_type_id, property_id, type_name, base_rate, max_occupancy, amenities FROM hospitality_technology.room_types WHERE base_rate > 200 AND max_occupancy >= 4;"}, {"role": "user", "content": "Now, join this with the guests table to show only room types from properties where the guest's country code is 'USA'."}, {"role": "assistant", "content": "SELECT rt.room_type_id, rt.property_id, rt.type_name, rt.base_rate, rt.max_occupancy, rt.amenities FROM hospitality_technology.room_types rt JOIN hospitality_technology.guests g ON rt.property_id = g.property_id WHERE rt.base_rate > 200 AND rt.max_occupancy >= 4 AND g.country_code = 'USA';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE hospitality_technology.room_types ( room_type_id text 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, first_name text, last_name text, email text, phone_number text, date_of_birth date, address_line1 text, city text, state_province text, postal_code text, country_code text, preferences text, loyalty_member_id text, communication_consent boolean, created_at timestamp, updated_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "Show me all claims handled by agent 'AG123' along with their settlement details and policy IDs."}, {"role": "assistant", "content": "SELECT claim_id, policy_id, settlement_amount, settlement_date FROM insurance.claims WHERE claim_handler_id = 'AG123';"}, {"role": "user", "content": "Now filter these to only show claims that were settled for more than $5,000 and include the incident description."}, {"role": "assistant", "content": "SELECT claim_id, policy_id, settlement_amount, settlement_date, description FROM insurance.claims WHERE claim_handler_id = 'AG123' AND settlement_amount > 5000;"}, {"role": "user", "content": "I also want to see how long it took to settle these claims (difference between reported_date and settlement_date in days)."}, {"role": "assistant", "content": "SELECT claim_id, policy_id, settlement_amount, settlement_date, description, EXTRACT(DAY FROM (settlement_date - reported_date)) AS days_to_settle FROM insurance.claims WHERE claim_handler_id = 'AG123' AND settlement_amount > 5000;"}, {"role": "user", "content": "Finally, order the results by the longest settlement time first and include only claims that took more than 30 days to settle."}, {"role": "assistant", "content": "SELECT claim_id, policy_id, settlement_amount, settlement_date, description, EXTRACT(DAY FROM (settlement_date - reported_date)) AS days_to_settle FROM insurance.claims WHERE claim_handler_id = 'AG123' AND settlement_amount > 5000 AND (settlement_date - reported_date) > INTERVAL '30 days' ORDER BY days_to_settle 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.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) )\n"}
{"conversations": [{"role": "user", "content": "Find services that have associated documents with a 'Pending' verification status. Show the service name and the document type name."}, {"role": "assistant", "content": "SELECT DISTINCT s.service_name, dt.document_type_name FROM government_services.services AS s JOIN government_services.applications AS a ON s.service_id = a.service_id JOIN government_services.application_documents AS ad ON a.application_id = ad.application_id JOIN government_services.document_types AS dt ON ad.document_type_id = dt.document_type_id WHERE ad.verification_status = 'Pending';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens (\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": "Which patients have insurance policies that are effective between May 1st, 2023 and October 1st, 2023? Show their patient_id, policy_number, and effective_date, and also include the related plan_id."}, {"role": "assistant", "content": "SELECT patient_id, policy_number, effective_date, plan_id FROM healthcare.patient_insurance WHERE effective_date >= '2023-05-01' AND effective_date <= '2023-10-01';"}, {"role": "user", "content": "I only want to see policies that are still primary. Could you adjust the query to add that condition?"}, {"role": "assistant", "content": "SELECT patient_id, policy_number, effective_date, plan_id FROM healthcare.patient_insurance WHERE effective_date >= '2023-05-01' AND effective_date <= '2023-10-01' AND is_primary = true;"}, {"role": "user", "content": "Actually, please also show only entries where the subscriber_name starts with the letter 'A'."}, {"role": "assistant", "content": "SELECT patient_id, policy_number, effective_date, plan_id FROM healthcare.patient_insurance WHERE effective_date >= '2023-05-01' AND effective_date <= '2023-10-01' AND is_primary = true AND subscriber_name LIKE 'A%';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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 events with their contract IDs and emitted timestamps, sorted by the most recent events first."}, {"role": "assistant", "content": "SELECT event_id, contract_id, emitted_at FROM web3.events ORDER BY emitted_at DESC;"}, {"role": "user", "content": "Actually, I only want to see events from contracts that start with '0x1234'."}, {"role": "assistant", "content": "SELECT event_id, contract_id, emitted_at FROM web3.events WHERE contract_id LIKE '0x1234%' ORDER BY emitted_at DESC;"}, {"role": "user", "content": "There's a typo in your SQL, it should be 'contract_id' not 'contract_id'. Also, add the event_name to the results."}, {"role": "assistant", "content": "SELECT event_id, contract_id, event_name, emitted_at FROM web3.events WHERE contract_id LIKE '0x1234%' ORDER BY emitted_at DESC;"}, {"role": "user", "content": "Now filter to only show events emitted in the last 24 hours."}, {"role": "assistant", "content": "SELECT event_id, contract_id, event_name, emitted_at FROM web3.events WHERE contract_id LIKE '0x1234%' AND emitted_at >= NOW() - INTERVAL '24 hours' ORDER BY emitted_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 web3.events ( event_id.text, contract_id.text, event_name.text, data.text, emitted_at.timestamp, transaction_id.text, log_index.integer )\n"}
{"conversations": [{"role": "user", "content": "What is the current operational status of the train car with car_id 'CAR123'?"}, {"role": "assistant", "content": "I'm sorry, but I can't provide information on the current operational status of the train car with car_id 'CAR123'. The data in the train_cars table does not include real-time status updates or operational conditions."}], "system": "You are an SQL statement expert and you can refuse the user's question if the question is not related to the table structure. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE train_station_management.train_cars ( car_id text PRIMARY KEY, train_id text, car_number text, car_type text, class text, capacity int, features text )\n"}
{"conversations": [{"role": "user", "content": "List 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 unique pairs of routes that share the same destination location, and show the route numbers and their type for both routes."}, {"role": "assistant", "content": "SELECT r1.route_number AS route_number_1, r1.type AS type_1, r2.route_number AS route_number_2, r2.type AS type_2, r1.destination_location_id\nFROM transportation.routes r1\nJOIN transportation.routes r2\n  ON r1.destination_location_id = r2.destination_location_id\n  AND r1.route_id < r2.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.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 )\n"}
{"conversations": [{"role": "user", "content": "Show all SUI coins with 'exists' status and more than 8 decimal places. Display coin_type, symbol, name, and decimals."}, {"role": "assistant", "content": "SELECT coin_type, symbol, name, decimals\nFROM sui_coins_metadata\nWHERE status = 'exists' AND decimals > 8;"}, {"role": "user", "content": "Add the total balance for each coin_type by joining with sui_coins."}, {"role": "assistant", "content": "SELECT scm.coin_type, scm.symbol, scm.name, scm.decimals, SUM(sc.balance::numeric) AS total_balance\nFROM sui_coins_metadata scm\nJOIN sui_coins sc ON scm.coin_type = sc.coin_type\nWHERE scm.status = 'exists' AND scm.decimals > 8\nGROUP BY scm.coin_type, scm.symbol, scm.name, scm.decimals;"}, {"role": "user", "content": "Can you also include only coins where the total_balance is greater than 1,000,000 and show the description?"}, {"role": "assistant", "content": "SELECT scm.coin_type, scm.symbol, scm.name, scm.decimals, scm.description, SUM(sc.balance::numeric) AS total_balance\nFROM sui_coins_metadata scm\nJOIN sui_coins sc ON scm.coin_type = sc.coin_type\nWHERE scm.status = 'exists' AND scm.decimals > 8\nGROUP BY scm.coin_type, scm.symbol, scm.name, scm.decimals, scm.description\nHAVING SUM(sc.balance::numeric) > 1000000;"}, {"role": "user", "content": "Actually, only show the top 5 coins with the highest total_balance."}, {"role": "assistant", "content": "SELECT scm.coin_type, scm.symbol, scm.name, scm.decimals, scm.description, SUM(sc.balance::numeric) AS total_balance\nFROM sui_coins_metadata scm\nJOIN sui_coins sc ON scm.coin_type = sc.coin_type\nWHERE scm.status = 'exists' AND scm.decimals > 8\nGROUP BY scm.coin_type, scm.symbol, scm.name, scm.decimals, scm.description\nHAVING SUM(sc.balance::numeric) > 1000000\nORDER BY total_balance 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 nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )\nCREATE TABLE sui_coins ( object_id varchar NOT NULL, status varchar NOT NULL, coin_type varchar NOT NULL, balance varchar NOT NULL, owner varchar NOT NULL )\nCREATE TABLE sui_coins_metadata (\n    object_id varchar NOT NULL, -- object id of the coin metadata object\n    coin_type varchar NOT NULL, -- coin type, eg. 0x...66::reap_token::REAP_TOKEN\n    status varchar NOT NULL, -- coin status, eg. exists, deleted\n    decimals bigint NOT NULL, -- decimals of the coin\n    description varchar NOT NULL, -- description of the coin\n    icon_url varchar NOT NULL, -- icon url of the coin\n    symbol varchar NOT NULL, -- symbol of the coin\n    name varchar NOT NULL  -- name of the coin\n)\nCREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )\nCREATE TABLE nft_metadata ( blockchain text, contract_address text, token_id text, contract_name text, erc_type text, amount bigint, minter text, owner text, mint_block_number bigint, mint_time bigint, mint_transaction_hash text, mint_price text, token_uri text, metadata text, name text, image_uri text, traits text, updated_at bigint, status text, rarity_score real, rarity_rank integer, unique_attribute_count integer, pk integer )\nCREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\nCREATE TABLE token_prices_latest (\n    blockchain varchar(36) NOT NULL, -- blockchain fields for the functionType  in contract\n    address varchar(42) NOT NULL, -- address fields for the functionType  in contract\n    decimals bigint NOT NULL, -- decimals fields for the functionType  in contract\n    symbol varchar(36) NOT NULL, -- symbol fields for the functionType  in contract\n    price real NOT NULL, -- price fields for the functionType  in contract\n    timestamp timestamp(6) NOT NULL  -- timestamp fields for the functionType  in contract\n)\nCREATE TABLE erc20_approval ( block_number bigint NOT NULL, block_timestamp timestamp(6) NOT NULL, transaction_index integer NOT NULL, transaction_hash varchar NOT NULL, log_index integer NOT NULL, contract_address varchar NOT NULL, pk integer NOT NULL )\nCREATE TABLE token_balances ( block_number.bigint, block_timestamp.timestamp, tick.text, wallet_address.text, total_supply.decimal, amount.decimal )\nCREATE TABLE token_info (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    tick varchar NOT NULL, -- Token tick\n    max_supply decimal(38,0) NOT NULL, -- Max supply\n    lim decimal(38,0) NOT NULL, -- Limit of each mint\n    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint\n    dec integer NOT NULL, -- Decimal for minimum divie\n    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)\n)\nCREATE TABLE mud_holesky_redstone (\n    address varchar NOT NULL, -- address fields for the functionType  in contract\n    table_id varchar NOT NULL, -- table_id fields for the functionType  in contract\n    key_bytes varchar NOT NULL, -- key_bytes fields for the functionType  in contract\n    key0 varchar NOT NULL, -- key0 fields for the functionType  in contract\n    key1 varchar NOT NULL, -- key1 fields for the functionType  in contract\n    static_data varchar NOT NULL, -- static_data fields for the functionType  in contract\n    encoded_lengths varchar NOT NULL, -- encoded_lengths fields for the functionType  in contract\n    dynamic_data varchar NOT NULL, -- dynamic_data fields for the functionType  in contract\n    is_deleted boolean NOT NULL, -- is_deleted fields for the functionType  in contract\n    block_number bigint NOT NULL, -- Block number uniquely identifying the block\n    log_index bigint NOT NULL  -- Index of the log within the transaction\n)\nCREATE TABLE token_info_bitcoin ( block_timestamp.timestamp, block_number.bigint, tx_index.integer, tx_hash.text, tick.text, max_supply.decimal, lim.decimal, wlim.decimal, dec.integer, creator.text )\nCREATE TABLE token_activities_avalanche (\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)\n    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)\n    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)\n    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)\n    log_index integer NOT NULL, -- Index of the log within the transaction\n    type varchar(20) NOT NULL, -- Operation: Type of event (deploy, mint, transfer, list)\n    tick varchar(255) NOT NULL, -- Ticker: Identifier of the inscription\n    id varchar(255) NOT NULL, -- Unique identifier of the inscription\n    amt decimal(38,0) NOT NULL, -- Amount to mint: States the amount of the inscription to operation. When operation is mint, has to be less or equal to \"lim\"\n    from_address varchar(42) NOT NULL, -- Address sending the inscription\n    to_address varchar(42) NOT NULL  -- Address receiving the inscription\n)\nCREATE TABLE token_balances_avalanche ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )\n"}
{"conversations": [{"role": "user", "content": "Show the total trade amount for each account. Include the account_id and account_number."}, {"role": "assistant", "content": "SELECT\n  T1.account_id,\n  T1.account_number,\n  SUM(T2.total_amount) AS total_traded_amount\nFROM financial_services.accounts AS T1\nINNER JOIN financial_services.trades AS T2\n  ON T1.account_id = T2.account_id\nGROUP BY\n  T1.account_id,\n  T1.account_number;"}, {"role": "user", "content": "Only include trades with a status of 'SETTLED'."}, {"role": "assistant", "content": "SELECT\n  T1.account_id,\n  T1.account_number,\n  SUM(T2.total_amount) AS total_traded_amount\nFROM financial_services.accounts AS T1\nINNER JOIN financial_services.trades AS T2\n  ON T1.account_id = T2.account_id\nWHERE\n  T2.status = 'SETTLED'\nGROUP BY\n  T1.account_id,\n  T1.account_number;"}, {"role": "user", "content": "Filter out accounts where the total traded amount for settled trades is less than 5000."}, {"role": "assistant", "content": "SELECT\n  T1.account_id,\n  T1.account_number,\n  SUM(T2.total_amount) AS total_traded_amount\nFROM financial_services.accounts AS T1\nINNER JOIN financial_services.trades AS T2\n  ON T1.account_id = T2.account_id\nWHERE\n  T2.status = 'SETTLED'\nGROUP BY\n  T1.account_id,\n  T1.account_number\nHAVING\n  SUM(T2.total_amount) >= 5000;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE financial_services.customers ( customer_id text, first_name text, last_name text, date_of_birth date, ssn_hash text, address text, city text, state text, zip_code text, country text, email text, phone_number text, created_at timestamp, status text, risk_profile text )\nCREATE TABLE financial_services.accounts ( account_id text, customer_id text, account_number text, account_type text, balance numeric, currency text, opened_date date, status text, interest_rate numeric, last_updated_at timestamp )\nCREATE TABLE financial_services.transactions (\n    transaction_id character varying(64) NOT NULL, -- unique identifier for the transaction\n    account_id character varying(64) NOT NULL, -- account involved in the transaction\n    related_account_id character varying(64), -- counterpart account for transfers\n    transaction_type character varying(50) NOT NULL, -- e.g., Deposit, Withdrawal, Transfer, Payment, Fee, Interest\n    amount numeric(19, 4) NOT NULL, -- transaction amount\n    currency character varying(3) NOT NULL, -- transaction currency\n    transaction_date timestamp NOT NULL, -- exact time of the transaction\n    effective_date date NOT NULL, -- date the transaction affects the balance\n    description text, -- description or memo of the transaction\n    status character varying(32) NOT NULL, -- e.g., Pending, Completed, Failed, Reversed\n    reference_number character varying(128), -- external reference if applicable (e.g., check number)\n    PRIMARY KEY (transaction_id),\n    FOREIGN KEY (account_id) REFERENCES financial_services.accounts(account_id),\n    FOREIGN KEY (related_account_id) REFERENCES financial_services.accounts(account_id)\n)\nCREATE TABLE financial_services.securities ( security_id.text, ticker_symbol.text, isin_code.text, cusip_code.text, security_name.text, security_type.text, exchange.text, currency.text, issuer_name.text, sector.text, last_updated.timestamp )\nCREATE TABLE financial_services.trades ( trade_id text PRIMARY KEY, account_id text, security_id text, order_id text, trade_type text, quantity numeric, price_per_unit numeric, total_amount numeric, commission numeric, trade_timestamp timestamp, settlement_date date, status text, execution_venue text )\nCREATE TABLE financial_services.market_data ( data_point_id.bigint, security_id.text, data_timestamp.timestamp, open_price.numeric, high_price.numeric, low_price.numeric, close_price.numeric, adjusted_close_price.numeric, volume.bigint, source.text )\nCREATE TABLE financial_services.employees (\n    employee_id character varying(64) NOT NULL,  -- unique identifier for the employee\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    job_title character varying(100) NOT NULL, -- e.g., Teller, Branch Manager, Financial Advisor, Analyst\n    department character varying(100), -- e.g., Retail Banking, Wealth Management, IT\n    branch_id character varying(64), -- Identifier for the branch they work at (if applicable)\n    email character varying(128) NOT NULL UNIQUE,\n    phone_extension character varying(20),\n    hire_date date NOT NULL,\n    termination_date date, -- Date of termination, null if currently employed\n    manager_id character varying(64), -- Self-referencing key for manager relationship\n    status character varying(32) NOT NULL, -- e.g., Active, Terminated, On Leave\n    PRIMARY KEY (employee_id),\n    FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), -- Assuming a branches table exists\n    FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id)\n)\n"}
{"conversations": [{"role": "user", "content": "I want a list of all claims where at least one document is larger than 2 megabytes. Include the claim ID, incident date, and the file name of such documents."}, {"role": "assistant", "content": "SELECT c.claim_id, c.incident_date, d.file_name\nFROM insurance.claims c\nJOIN insurance.claim_documents d ON c.claim_id = d.claim_id\nWHERE d.file_size_bytes > 2097152;"}, {"role": "user", "content": "Actually, please also show the document type and only include documents uploaded after June 1, 2024."}, {"role": "assistant", "content": "SELECT c.claim_id, c.incident_date, d.file_name, d.document_type\nFROM insurance.claims c\nJOIN insurance.claim_documents d ON c.claim_id = d.claim_id\nWHERE d.file_size_bytes > 2097152\n  AND d.uploaded_at > '2024-06-01';"}, {"role": "user", "content": "Add the file size in kilobytes and order the results by file size descending."}, {"role": "assistant", "content": "SELECT c.claim_id, c.incident_date, d.file_name, d.document_type, (d.file_size_bytes/1024) AS file_size_kb\nFROM insurance.claims c\nJOIN insurance.claim_documents d ON c.claim_id = d.claim_id\nWHERE d.file_size_bytes > 2097152\n  AND d.uploaded_at > '2024-06-01'\nORDER BY d.file_size_bytes DESC;"}, {"role": "user", "content": "Sorry, I'm getting some records where file_size_bytes is NULL. Please exclude those from the results."}, {"role": "assistant", "content": "SELECT c.claim_id, c.incident_date, d.file_name, d.document_type, (d.file_size_bytes/1024) AS file_size_kb\nFROM insurance.claims c\nJOIN insurance.claim_documents d ON c.claim_id = d.claim_id\nWHERE d.file_size_bytes > 2097152\n  AND d.uploaded_at > '2024-06-01'\n  AND d.file_size_bytes IS NOT NULL\nORDER BY d.file_size_bytes 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.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.claim_documents ( document_id text PRIMARY KEY, claim_id text, document_type text, file_name text, file_path text, file_size_bytes int, mime_type text, uploaded_by text, uploaded_at timestamp, description text )\n"}
{"conversations": [{"role": "user", "content": "List all medical records created in the last 7 days, including patient_id, doctor_id, and record_date."}, {"role": "assistant", "content": "SELECT patient_id, doctor_id, record_date FROM healthcare.medical_records WHERE created_at >= CURRENT_DATE - INTERVAL '7 days';"}, {"role": "user", "content": "Actually, I only need records where the treatment_plan is not empty."}, {"role": "assistant", "content": "SELECT patient_id, doctor_id, record_date FROM healthcare.medical_records WHERE created_at >= CURRENT_DATE - INTERVAL '7 days' AND treatment_plan IS NOT NULL AND treatment_plan != '';"}, {"role": "user", "content": "Can you also sort them by record_date in descending order?"}, {"role": "assistant", "content": "SELECT patient_id, doctor_id, record_date FROM healthcare.medical_records WHERE created_at >= CURRENT_DATE - INTERVAL '7 days' AND treatment_plan IS NOT NULL AND treatment_plan != '' ORDER BY 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.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 )\n"}
{"conversations": [{"role": "user", "content": "Show me assets along with their associated 'symbol' metadata value. Assume an assets table with asset_id exists."}, {"role": "assistant", "content": "SELECT a.asset_id, m.value FROM assets a JOIN metadata m ON a.asset_id = m.asset_id WHERE m.key = 'symbol'"}, {"role": "user", "content": "Now, also include the 'name' metadata value for these assets in the same result."}, {"role": "assistant", "content": "SELECT a.asset_id, m_symbol.value AS symbol, m_name.value AS name FROM assets a LEFT JOIN metadata m_symbol ON a.asset_id = m_symbol.asset_id AND m_symbol.key = 'symbol' LEFT JOIN metadata m_name ON a.asset_id = m_name.asset_id AND m_name.key = 'name'"}, {"role": "user", "content": "For assets that have both 'symbol' and 'name' metadata, list the asset ID and the count of *all* metadata entries they have."}, {"role": "assistant", "content": "SELECT a.asset_id, COUNT(m_all.metadata_id) FROM assets a JOIN metadata m_symbol ON a.asset_id = m_symbol.asset_id AND m_symbol.key = 'symbol' JOIN metadata m_name ON a.asset_id = m_name.asset_id AND m_name.key = 'name' JOIN metadata m_all ON a.asset_id = m_all.asset_id GROUP BY a.asset_id"}], "system": "You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement. \n##Table Structure\nCREATE TABLE trading_platform.utxos ( utxo_id text PRIMARY KEY, transaction_id text, output_index int, address text, amount numeric, spent boolean )\nCREATE TABLE trading_platform.dapps ( dapp_id text PRIMARY KEY, name text, description text, url text )\nCREATE TABLE trading_platform.peers ( peer_id text PRIMARY KEY, ip_address text, port int, last_seen timestamp )\nCREATE TABLE trading_platform.metadata ( metadata_id text PRIMARY KEY, asset_id text, key text, value text )\nCREATE TABLE trading_platform.notifications ( notification_id text PRIMARY KEY, user_id text, message text, sent_at timestamp, read_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List all wallet addresses that hold any NFT currently. Show the wallet address and the count of distinct token IDs they hold."}, {"role": "assistant", "content": "SELECT wallet_address, COUNT(DISTINCT token_id) FROM nft_holders GROUP BY wallet_address;"}, {"role": "user", "content": "Filter the list to only include wallets that hold more than 5 unique NFTs."}, {"role": "assistant", "content": "SELECT wallet_address, COUNT(DISTINCT token_id) FROM nft_holders GROUP BY wallet_address HAVING COUNT(DISTINCT token_id) > 5;"}, {"role": "user", "content": "Order the results by the count of unique NFTs held in descending order."}, {"role": "assistant", "content": "SELECT wallet_address, COUNT(DISTINCT token_id) AS unique_nft_count FROM nft_holders GROUP BY wallet_address HAVING COUNT(DISTINCT token_id) > 5 ORDER BY unique_nft_count DESC;"}, {"role": "user", "content": "Limit the output to the top 20 wallets."}, {"role": "assistant", "content": "SELECT wallet_address, COUNT(DISTINCT token_id) AS unique_nft_count FROM nft_holders GROUP BY wallet_address HAVING COUNT(DISTINCT token_id) > 5 ORDER BY unique_nft_count DESC LIMIT 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 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_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_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": "Get the average overall review rating for each property. Return property_name and avg_rating."}, {"role": "assistant", "content": "SELECT pr.property_name, AVG(r.rating_overall) AS avg_rating\nFROM hospitality_technology.reviews r\nJOIN hospitality_technology.properties pr ON r.property_id = pr.property_id\nGROUP BY pr.property_name;"}, {"role": "user", "content": "Filter to only include properties with an average overall rating above 4.0."}, {"role": "assistant", "content": "SELECT pr.property_name, AVG(r.rating_overall) AS avg_rating\nFROM hospitality_technology.reviews r\nJOIN hospitality_technology.properties pr ON r.property_id = pr.property_id\nGROUP BY pr.property_name\nHAVING AVG(r.rating_overall) > 4.0;"}, {"role": "user", "content": "Additionally, include the total number of reviews per property and order the results by avg_rating descending."}, {"role": "assistant", "content": "SELECT pr.property_name,\n       AVG(r.rating_overall) AS avg_rating,\n       COUNT(r.review_id) AS review_count\nFROM hospitality_technology.reviews r\nJOIN hospitality_technology.properties pr ON r.property_id = pr.property_id\nGROUP BY pr.property_name\nHAVING AVG(r.rating_overall) > 4.0\nORDER BY avg_rating 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.guests (\n    guest_id character varying(64) NOT NULL,  -- unique identifier for the guest profile\n    first_name character varying(100) NOT NULL, -- guest's first name\n    last_name character varying(100) NOT NULL, -- guest's last name\n    email character varying(255) UNIQUE, -- guest's email address (unique identifier?)\n    phone_number character varying(30), -- guest's phone number\n    date_of_birth date, -- guest's date of birth\n    address_line1 character varying(255), -- guest's home address\n    city character varying(100),\n    state_province character varying(100),\n    postal_code character varying(20),\n    country_code character varying(3),\n    preferences text, -- notes on guest preferences (e.g., allergies, room location)\n    loyalty_member_id character varying(64) UNIQUE, -- FK to loyalty_members table\n    communication_consent boolean DEFAULT true, -- consent for marketing communications\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 (guest_id)\n)\nCREATE TABLE hospitality_technology.staff (\n    staff_id character varying(64) NOT NULL,  -- unique identifier for the staff member\n    property_id character varying(64) NOT NULL, -- FK to properties table (primary property)\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    position character varying(100) NOT NULL, -- e.g., Front Desk Agent, Housekeeper, Manager, Concierge\n    work_email character varying(255) UNIQUE, -- staff member's work email\n    work_phone character varying(30),\n    hire_date date NOT NULL,\n    termination_date date, -- date employment ended (if applicable)\n    is_active boolean NOT NULL DEFAULT true, -- currently employed flag\n    access_level integer NOT NULL, -- permission level within systems (e.g., 1=basic, 5=admin)\n    manager_id character varying(64), -- FK to staff table (self-referencing for supervisor)\n    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,\n    PRIMARY KEY (staff_id),\n    FOREIGN KEY (property_id) REFERENCES hospitality_technology.properties(property_id),\n    FOREIGN KEY (manager_id) REFERENCES hospitality_technology.staff(staff_id)\n)\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)\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": "List all log entries associated with users who have participated in any trade, showing the log details and the trade ID."}, {"role": "assistant", "content": "SELECT T1.log_id, T1.action, T1.details, T1.logged_at, T2.trade_id, T2.buyer_id, T2.seller_id FROM logs AS T1 JOIN trades AS T2 ON T1.user_id = T2.buyer_id OR T1.user_id = T2.seller_id;"}, {"role": "user", "content": "Only show logs and trades that occurred in the last week."}, {"role": "assistant", "content": "SELECT T1.log_id, T1.action, T1.details, T1.logged_at, T2.trade_id, T2.buyer_id, T2.seller_id FROM logs AS T1 JOIN trades AS T2 ON T1.user_id = T2.buyer_id OR T1.user_id = T2.seller_id WHERE T1.logged_at >= datetime('now', '-7 days') AND T2.traded_at >= datetime('now', '-7 days');"}, {"role": "user", "content": "Can you instead provide a count of such log entries per user who traded, for the last week?"}, {"role": "assistant", "content": "SELECT T1.user_id, COUNT(DISTINCT T1.log_id) AS log_count FROM logs AS T1 JOIN trades AS T2 ON T1.user_id = T2.buyer_id OR T1.user_id = T2.seller_id WHERE T1.logged_at >= datetime('now', '-7 days') AND T2.traded_at >= datetime('now', '-7 days') GROUP BY T1.user_id;"}, {"role": "user", "content": "Also include the total number of trades for each user in the same period and sort by trade count descending."}, {"role": "assistant", "content": "SELECT T1.user_id, COUNT(DISTINCT T1.log_id) AS log_count, COUNT(DISTINCT T2.trade_id) AS trade_count FROM logs AS T1 JOIN trades AS T2 ON T1.user_id = T2.buyer_id OR T1.user_id = T2.seller_id WHERE T1.logged_at >= datetime('now', '-7 days') AND T2.traded_at >= datetime('now', '-7 days') GROUP BY T1.user_id ORDER BY trade_count DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE trading_platform.wallets ( wallet_id.text, user_id.text, address.text, private_key.text, created_at.timestamp )\nCREATE TABLE trading_platform.trades ( trade_id.text, order_id.text, buyer_id.text, seller_id.text, asset_id.text, quantity.numeric, price.numeric, traded_at.timestamp )\nCREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )\nCREATE TABLE trading_platform.dapps ( dapp_id.text, name.text, description.text, url.text )\nCREATE TABLE trading_platform.peers ( peer_id.text, ip_address.text, port.integer, last_seen.timestamp )\nCREATE TABLE trading_platform.logs ( log_id.text, user_id.text, action.text, details.text, logged_at.timestamp )\n"}
{"conversations": [{"role": "user", "content": "List all 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": "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.1."}, {"role": "assistant", "content": "SELECT tm.name, tm.contract_address, tm.total_supply, tpl.price FROM token_metas tm JOIN token_prices_latest tpl ON tm.contract_address = tpl.address WHERE tm.is_erc20 = 1 AND tpl.price > 0.1 ORDER BY CAST(tm.total_supply AS decimal) DESC LIMIT 5;"}, {"role": "user", "content": "I think there's an error in your query - it should be 'tpl.symbol' not 'tm.symbol'. Also, can you add the decimals to the results?"}, {"role": "assistant", "content": "SELECT tm.name, tm.contract_address, tm.decimals, tm.total_supply, tpl.symbol, tpl.price FROM token_metas tm JOIN token_prices_latest tpl ON tm.contract_address = tpl.address WHERE tm.is_erc20 = 1 AND tpl.price > 0.1 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.contract_address, tm.decimals, tm.total_supply, tpl.symbol, tpl.price FROM token_metas tm JOIN token_prices_latest tpl ON tm.contract_address = tpl.address WHERE tm.is_erc20 = 1 AND tpl.price > 0.1 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, 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 erc20_balances ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk varchar )\nCREATE TABLE erc20_balances_historical ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk integer )\nCREATE TABLE nft_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 sui_nfts ( object_id varchar, status varchar, collection_type varchar, package_id varchar, previous_transaction varchar, display varchar, owner varchar, name varchar )\nCREATE TABLE nft_metadata ( blockchain varchar, contract_address varchar, token_id varchar, contract_name varchar, erc_type varchar, amount bigint, minter varchar, owner varchar, mint_block_number bigint, mint_time bigint, mint_transaction_hash varchar, mint_price varchar, token_uri varchar, metadata varchar, name varchar, image_uri varchar, traits varchar, updated_at bigint, status varchar, rarity_score real, rarity_rank integer, unique_attribute_count integer, pk integer )\nCREATE TABLE token_prices ( uuid varchar, blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE token_prices_latest ( blockchain varchar, address varchar, decimals bigint, symbol varchar, price real, timestamp timestamp )\nCREATE TABLE erc20_approval ( block_number bigint, block_timestamp timestamp, transaction_index integer, transaction_hash varchar, log_index integer, contract_address varchar, pk integer )\nCREATE TABLE token_balances ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )\nCREATE TABLE token_info ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash varchar, tick varchar, max_supply decimal, lim decimal, wlim decimal, dec integer, creator varchar )\nCREATE TABLE token_activities ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash varchar, log_index integer, type varchar, tick varchar, id varchar, amt decimal, from_address varchar, to_address varchar )\nCREATE TABLE mud_holesky_redstone ( address varchar, table_id varchar, key_bytes varchar, key0 varchar, key1 varchar, static_data varchar, encoded_lengths varchar, dynamic_data varchar, is_deleted boolean, block_number bigint, log_index bigint )\nCREATE TABLE token_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 ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )\n"}
{"conversations": [{"role": "user", "content": "Show me document_id, application_id, and verification_status for all documents submitted by citizen 'cit123'."}, {"role": "assistant", "content": "SELECT document_id,\n       application_id,\n       verification_status\nFROM documents\nWHERE citizen_id = 'cit123';"}, {"role": "user", "content": "I got an error: relation 'documents' does not exist."}, {"role": "assistant", "content": "SELECT document_id,\n       application_id,\n       verification_status\nFROM government_services.documents\nWHERE citizen_id = 'cit123';"}, {"role": "user", "content": "Now, only include documents where verification_status = 'Pending'."}, {"role": "assistant", "content": "SELECT document_id,\n       application_id,\n       verification_status\nFROM government_services.documents\nWHERE citizen_id = 'cit123'\n  AND verification_status = 'Pending';"}, {"role": "user", "content": "Also, limit the results to files uploaded in 2024."}, {"role": "assistant", "content": "SELECT document_id,\n       application_id,\n       verification_status\nFROM government_services.documents\nWHERE citizen_id = 'cit123'\n  AND verification_status = 'Pending'\n  AND upload_timestamp >= '2024-01-01'\n  AND upload_timestamp < '2025-01-01';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id text, national_id_number text, first_name text, last_name text, date_of_birth date, gender text, primary_address text, contact_email text, contact_phone text, registration_date timestamp, is_verified boolean )\nCREATE TABLE government_services.applications ( application_id text, citizen_id text, service_id text, submitted_at timestamp, status text, last_updated_at timestamp, assigned_employee_id text, decision_date date, notes text, reference_number text )\nCREATE TABLE government_services.documents ( document_id text, application_id text, citizen_id text, document_type text, file_reference text, upload_timestamp timestamp, expiry_date date, verification_status text, verified_by_employee_id text, verification_timestamp timestamp )\nCREATE TABLE government_services.employees ( employee_id text, agency_id text, first_name text, last_name text, job_title text, department text, work_email text, work_phone text, hire_date date, termination_date date, access_level text, manager_employee_id text )\nCREATE TABLE government_services.service_locations ( location_id text, agency_id text, location_name text, address text, city text, state text, postal_code text, latitude numeric, longitude numeric, operating_hours text, contact_phone text, is_accessible boolean )\nCREATE TABLE government_services.appointments ( appointment_id text, citizen_id text, employee_id text, location_id text, service_id text, scheduled_start_time timestamp, scheduled_end_time timestamp, purpose text, status text, booking_method text, created_at timestamp, notes text )\n"}
{"conversations": [{"role": "user", "content": "List the transaction IDs and gas used for transactions where gas used is greater than 500000."}, {"role": "assistant", "content": "SELECT transaction_id, gas_used FROM web3.transactions WHERE gas_used > 500000;"}, {"role": "user", "content": "Order the results by gas used in descending order."}, {"role": "assistant", "content": "SELECT transaction_id, gas_used FROM web3.transactions WHERE gas_used > 500000 ORDER BY gas_used 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.users ( user_id text, username text, email text, password_hash text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List the case number, case name, and the full name of the client for cases that have uploaded documents."}, {"role": "assistant", "content": "SELECT T1.case_number ,  T1.case_name ,  T2.full_name FROM legal_services.cases AS T1 JOIN legal_services.clients AS T2 ON T1.client_id  =  T2.client_id WHERE EXISTS ( SELECT 1 FROM legal_services.documents AS T3 WHERE T3.case_id  =  T1.case_id )"}, {"role": "user", "content": "Also include the full name of the lead lawyer for these cases."}, {"role": "assistant", "content": "SELECT T1.case_number ,  T1.case_name ,  T2.full_name AS client_name ,  T4.full_name AS lawyer_name FROM legal_services.cases AS T1 JOIN legal_services.clients AS T2 ON T1.client_id  =  T2.client_id JOIN legal_services.lawyers AS T4 ON T1.lead_lawyer_id  =  T4.lawyer_id WHERE EXISTS ( SELECT 1 FROM legal_services.documents AS T3 WHERE T3.case_id  =  T1.case_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.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": "I need to find all pairs of medications that share the same manufacturer. For each pair, show the first medication's ID and name, the second medication's ID and name, and the manufacturer."}, {"role": "assistant", "content": "SELECT m1.medication_id AS med1_id,\n       m1.medication_name AS med1_name,\n       m2.medication_id AS med2_id,\n       m2.medication_name AS med2_name,\n       m1.manufacturer\nFROM healthcare.medications m1\nJOIN healthcare.medications m2\n  ON m1.manufacturer = m2.manufacturer\n AND m1.medication_id < m2.medication_id;"}, {"role": "user", "content": "Actually, only include pairs where the two medications have different generic_name values."}, {"role": "assistant", "content": "SELECT m1.medication_id AS med1_id,\n       m1.medication_name AS med1_name,\n       m2.medication_id AS med2_id,\n       m2.medication_name AS med2_name,\n       m1.manufacturer\nFROM healthcare.medications m1\nJOIN healthcare.medications m2\n  ON m1.manufacturer = m2.manufacturer\n AND m1.medication_id < m2.medication_id\nWHERE m1.generic_name <> m2.generic_name;"}, {"role": "user", "content": "Also, exclude any pairs where the manufacturer field is NULL for either medication."}, {"role": "assistant", "content": "SELECT m1.medication_id AS med1_id,\n       m1.medication_name AS med1_name,\n       m2.medication_id AS med2_id,\n       m2.medication_name AS med2_name,\n       m1.manufacturer\nFROM healthcare.medications m1\nJOIN healthcare.medications m2\n  ON m1.manufacturer = m2.manufacturer\n AND m1.medication_id < m2.medication_id\nWHERE m1.generic_name <> m2.generic_name\n  AND m1.manufacturer IS NOT NULL\n  AND m2.manufacturer IS NOT NULL;"}, {"role": "user", "content": "Finally, limit the result to manufacturers that have at least three medications in the table."}, {"role": "assistant", "content": "SELECT m1.medication_id AS med1_id,\n       m1.medication_name AS med1_name,\n       m2.medication_id AS med2_id,\n       m2.medication_name AS med2_name,\n       m1.manufacturer\nFROM healthcare.medications m1\nJOIN healthcare.medications m2\n  ON m1.manufacturer = m2.manufacturer\n AND m1.medication_id < m2.medication_id\nWHERE m1.generic_name <> m2.generic_name\n  AND m1.manufacturer IS NOT NULL\n  AND m2.manufacturer IS NOT NULL\n  AND m1.manufacturer IN (\n      SELECT manufacturer\n      FROM healthcare.medications\n      WHERE manufacturer IS NOT NULL\n      GROUP BY manufacturer\n      HAVING COUNT(*) >= 3\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 healthcare.medications ( medication_id text, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )\n"}
{"conversations": [{"role": "user", "content": "Find all addresses with a balance greater than 1000, ordered by balance in descending order."}, {"role": "assistant", "content": "SELECT address_id, public_key, balance FROM blockchain.addresses WHERE balance > 1000 ORDER BY balance DESC;"}, {"role": "user", "content": "Now, join this with another query to show the difference between each address's balance and the average balance of all addresses."}, {"role": "assistant", "content": "SELECT a.address_id, a.public_key, a.balance, (a.balance - (SELECT AVG(balance) FROM blockchain.addresses)) AS balance_difference FROM blockchain.addresses a WHERE a.balance > 1000 ORDER BY a.balance DESC;"}, {"role": "user", "content": "Can you modify this to show the percentage difference instead of absolute difference?"}, {"role": "assistant", "content": "SELECT a.address_id, a.public_key, a.balance, ((a.balance - (SELECT AVG(balance) FROM blockchain.addresses)) / (SELECT AVG(balance) FROM blockchain.addresses)) * 100 AS percentage_difference FROM blockchain.addresses a WHERE a.balance > 1000 ORDER BY a.balance DESC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE blockchain.addresses ( address_id text PRIMARY KEY, public_key text, balance numeric )\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": "How many unread notifications are there with the type 'mention'?"}, {"role": "assistant", "content": "SELECT COUNT(*) FROM social_media.notifications WHERE read_at IS NULL AND notification_type = 'mention';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE social_media.conversations ( conversation_id text PRIMARY KEY, created_at timestamp, last_message_at timestamp, is_group_chat bool, group_name text )\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 a summary of all clients with the total number of invoices they've received and the sum of total_amount for those invoices."}, {"role": "assistant", "content": "SELECT cl.client_id,\n       CONCAT(cl.first_name, ' ', cl.last_name) AS client_name,\n       COUNT(inv.invoice_id) AS invoice_count,\n       SUM(inv.total_amount) AS total_amount_sum\nFROM legal_services.clients cl\nLEFT JOIN legal_services.invoices inv ON cl.client_id = inv.client_id\nGROUP BY cl.client_id, cl.first_name, cl.last_name;"}, {"role": "user", "content": "I'd like to consider only invoices issued in the year 2023."}, {"role": "assistant", "content": "SELECT cl.client_id,\n       CONCAT(cl.first_name, ' ', cl.last_name) AS client_name,\n       COUNT(inv.invoice_id) AS invoice_count,\n       SUM(inv.total_amount) AS total_amount_sum\nFROM legal_services.clients cl\nLEFT JOIN legal_services.invoices inv ON cl.client_id = inv.client_id\nWHERE inv.issue_date BETWEEN '2023-01-01' AND '2023-12-31'\nGROUP BY cl.client_id, cl.first_name, cl.last_name;"}, {"role": "user", "content": "And exclude clients who have not paid any amount on any of their invoices."}, {"role": "assistant", "content": "SELECT cl.client_id,\n       CONCAT(cl.first_name, ' ', cl.last_name) AS client_name,\n       COUNT(inv.invoice_id) AS invoice_count,\n       SUM(inv.total_amount) AS total_amount_sum,\n       SUM(inv.amount_paid) AS amount_paid_sum\nFROM legal_services.clients cl\nLEFT JOIN legal_services.invoices inv ON cl.client_id = inv.client_id\nWHERE inv.issue_date BETWEEN '2023-01-01' AND '2023-12-31'\nGROUP BY cl.client_id, cl.first_name, cl.last_name\nHAVING SUM(inv.amount_paid) > 0;"}, {"role": "user", "content": "Finally, order the results by the sum of total_amount in descending order."}, {"role": "assistant", "content": "SELECT cl.client_id,\n       CONCAT(cl.first_name, ' ', cl.last_name) AS client_name,\n       COUNT(inv.invoice_id) AS invoice_count,\n       SUM(inv.total_amount) AS total_amount_sum,\n       SUM(inv.amount_paid) AS amount_paid_sum\nFROM legal_services.clients cl\nLEFT JOIN legal_services.invoices inv ON cl.client_id = inv.client_id\nWHERE inv.issue_date BETWEEN '2023-01-01' AND '2023-12-31'\nGROUP BY cl.client_id, cl.first_name, cl.last_name\nHAVING SUM(inv.amount_paid) > 0\nORDER BY total_amount_sum 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 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.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.invoices ( invoice_id character varying(64) NOT NULL, invoice_number character varying(100) UNIQUE NOT NULL, client_id character varying(64) NOT NULL, case_id character varying(64), issue_date date NOT NULL, due_date date NOT NULL, total_amount numeric(12, 2) NOT NULL, amount_paid numeric(12, 2) DEFAULT 0.00, status character varying(50) NOT NULL, payment_date timestamp, notes text, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (invoice_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 pairs of insurance plans that are offered by the same insurance provider. Show the provider name, and the names of the two plans."}, {"role": "assistant", "content": "SELECT p1.insurance_provider, p1.plan_name, p2.plan_name FROM healthcare.insurance_plans p1 JOIN healthcare.insurance_plans p2 ON p1.insurance_provider = p2.insurance_provider AND p1.plan_id < p2.plan_id ORDER BY p1.insurance_provider, p1.plan_name;"}, {"role": "user", "content": "Only show pairs where the provider name starts with 'B'."}, {"role": "assistant", "content": "SELECT p1.insurance_provider, p1.plan_name, p2.plan_name FROM healthcare.insurance_plans p1 JOIN healthcare.insurance_plans p2 ON p1.insurance_provider = p2.insurance_provider AND p1.plan_id < p2.plan_id WHERE p1.insurance_provider LIKE 'B%' ORDER BY p1.insurance_provider, p1.plan_name;"}, {"role": "user", "content": "Further filter to include only pairs where both plans have a website listed."}, {"role": "assistant", "content": "SELECT p1.insurance_provider, p1.plan_name, p2.plan_name FROM healthcare.insurance_plans p1 JOIN healthcare.insurance_plans p2 ON p1.insurance_provider = p2.insurance_provider AND p1.plan_id < p2.plan_id WHERE p1.insurance_provider LIKE 'B%' AND p1.website IS NOT NULL AND p2.website IS NOT NULL ORDER BY p1.insurance_provider, p1.plan_name;"}, {"role": "user", "content": "Also, include the plan type for both plans in the result."}, {"role": "assistant", "content": "SELECT p1.insurance_provider, p1.plan_name, p1.plan_type, p2.plan_name, p2.plan_type FROM healthcare.insurance_plans p1 JOIN healthcare.insurance_plans p2 ON p1.insurance_provider = p2.insurance_provider AND p1.plan_id < p2.plan_id WHERE p1.insurance_provider LIKE 'B%' AND p1.website IS NOT NULL AND p2.website IS NOT NULL ORDER BY p1.insurance_provider, p1.plan_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 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) )\n"}
{"conversations": [{"role": "user", "content": "Please show me all locations that do not have a state or province recorded. Include the location name, city, and country."}, {"role": "assistant", "content": "SELECT name, city, country\nFROM transportation.locations\nWHERE state_province IS NULL OR state_province = '';"}, {"role": "user", "content": "For these locations, also include their location_id and type."}, {"role": "assistant", "content": "SELECT location_id, name, type, city, country\nFROM transportation.locations\nWHERE state_province IS NULL OR state_province = '';"}, {"role": "user", "content": "Could you additionally list any routes for which these locations are either the origin or the destination? Show the location name, route number, and specify if the location is origin or destination."}, {"role": "assistant", "content": "SELECT l.name, r.route_number,\n  CASE \n    WHEN r.origin_location_id = l.location_id THEN 'origin'\n    WHEN r.destination_location_id = l.location_id THEN 'destination'\n  END AS role\nFROM transportation.locations l\nJOIN transportation.routes r\n  ON r.origin_location_id = l.location_id OR r.destination_location_id = l.location_id\nWHERE l.state_province IS NULL OR l.state_province = '';"}], "system": "You are an SQL statement expert. Given the table structure 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 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.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.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 each contract's address along with the total number of events it has emitted and the total number of transactions sent to it."}, {"role": "assistant", "content": "SELECT\n  c.address,\n  COUNT(e.event_id) AS event_count,\n  COUNT(t.transaction_id) AS tx_count\nFROM web3.contracts c\nLEFT JOIN web3.events e\n  ON c.contract_id = e.contract_id\nLEFT JOIN web3.transactions t\n  ON c.address = t.to_address\nGROUP BY c.address;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.contracts (\n    contract_id character varying(64) NOT NULL,  -- unique identifier for the contract\n    address character varying(128) NOT NULL, -- address of the deployed contract\n    abi text NOT NULL, -- application binary interface of the contract\n    bytecode text NOT NULL, -- bytecode of the contract\n    deployer_address character varying(128) NOT NULL, -- address of the deployer\n    deployed_at timestamp NOT NULL, -- time when the contract was deployed\n    network_id character varying(64) NOT NULL, -- identifier of the network where the contract is deployed\n    status character varying(32) NOT NULL, -- status of the contract (e.g., active, deprecated)\n    PRIMARY KEY (contract_id)\n)\nCREATE TABLE web3.events (\n    event_id character varying(64) NOT NULL,  -- unique identifier for the event\n    contract_id character varying(64) NOT NULL, -- identifier of the contract emitting the event\n    event_name character varying(128) NOT NULL, -- name of the event\n    data text NOT NULL, -- data payload of the event\n    emitted_at timestamp NOT NULL, -- time when the event was emitted\n    transaction_id character varying(64) NOT NULL, -- identifier of the transaction that triggered the event\n    log_index integer NOT NULL, -- index of the event log in the transaction\n    PRIMARY KEY (event_id)\n)\nCREATE TABLE web3.transactions (\n    transaction_id character varying(64) NOT NULL,  -- unique identifier for the transaction\n    from_address character varying(128) NOT NULL, -- address of the sender\n    to_address character varying(128), -- address of the receiver (can be null for contract deployment)\n    value numeric(38,14) NOT NULL, -- value transferred\n    gas_used integer NOT NULL, -- amount of gas used by the transaction\n    gas_price numeric(38,14) NOT NULL, -- price of gas at the time of the transaction\n    block_number integer NOT NULL, -- block number containing the transaction\n    timestamp timestamp NOT NULL, -- time when the transaction was mined\n    input_data text, -- input data of the transaction (can be null)\n    status character varying(32) NOT NULL, -- status of the transaction (e.g., success, failed)\n    nonce integer NOT NULL, -- nonce of the sender at the time of the transaction\n    PRIMARY KEY (transaction_id)\n)\nCREATE TABLE web3.tokens (\n    token_id character varying(64) NOT NULL,  -- unique identifier for the token\n    contract_address character varying(128) NOT NULL, -- address of the token contract\n    token_name character varying(128) NOT NULL, -- name of the token\n    token_symbol character varying(32) NOT NULL, -- symbol of the token\n    decimals integer NOT NULL, -- number of decimals for the token\n    total_supply numeric(38,14) NOT NULL, -- total supply of the token\n    PRIMARY KEY (token_id)\n)\nCREATE TABLE web3.token_transfers (\n    transfer_id character varying(64) NOT NULL,  -- unique identifier for the transfer\n    token_id character varying(64) NOT NULL, -- identifier of the token being transferred\n    from_address character varying(128) NOT NULL, -- address of the sender\n    to_address character varying(128) NOT NULL, -- address of the receiver\n    value numeric(38,14) NOT NULL, -- amount of tokens transferred\n    transaction_id character varying(64) NOT NULL, -- identifier of the transaction containing the transfer\n    log_index integer NOT NULL, -- index of the transfer log in the transaction\n    PRIMARY KEY (transfer_id)\n)\nCREATE TABLE web3.users (\n    user_id character varying(64) NOT NULL,  -- unique identifier for the user\n    username character varying(128) NOT NULL, -- username of the user\n    email character varying(128) NOT NULL, -- email address of the user\n    password_hash text NOT NULL, -- hashed password of the user\n    created_at timestamp NOT NULL, -- time when the user account was created\n    PRIMARY KEY (user_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me the list of hashtags that have been used, along with the time they were first used."}, {"role": "assistant", "content": "SELECT tag_name, created_at \nFROM social_media.hashtags;"}], "system": "You are an SQL statement expert. Given the table structure 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.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)\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 each group conversation with its group name and the number of verified users who have posted in it."}, {"role": "assistant", "content": "SELECT c.conversation_id, c.group_name, COUNT(DISTINCT u.user_id) AS verified_posters\nFROM social_media.conversations c\nJOIN social_media.posts p ON p.location_lat IS NOT NULL -- Simulate posts linked to conversation (since no mapping, using location as a proxy)\nJOIN social_media.users u ON p.user_id = u.user_id AND u.is_verified = true\nWHERE c.is_group_chat = true\nGROUP BY c.conversation_id, c.group_name;"}, {"role": "user", "content": "Actually, only show groups created after May 1, 2024."}, {"role": "assistant", "content": "SELECT c.conversation_id, c.group_name, COUNT(DISTINCT u.user_id) AS verified_posters\nFROM social_media.conversations c\nJOIN social_media.posts p ON p.location_lat IS NOT NULL -- Simulate posts linked to conversation (since no mapping, using location as a proxy)\nJOIN social_media.users u ON p.user_id = u.user_id AND u.is_verified = true\nWHERE c.is_group_chat = true AND c.created_at > '2024-05-01'\nGROUP BY c.conversation_id, c.group_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 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.hashtags ( hashtag_id text PRIMARY KEY, tag_name text, created_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.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": "Show the prescription ID, medication name, and patient full name for all prescriptions issued in the last 30 days."}, {"role": "assistant", "content": "SELECT pr.prescription_id, m.medication_name, CONCAT(p.first_name, ' ', p.last_name) AS patient_name\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\nWHERE pr.prescription_date >= CURRENT_DATE - INTERVAL '30 days';"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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.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.appointments ( appointment_id.text, patient_id.text, doctor_id.text, appointment_time.timestamp, duration_minutes.integer, reason.text, status.text, location_id.text, notes.text, created_at.timestamp )\nCREATE TABLE healthcare.medical_records ( record_id text PRIMARY KEY, patient_id text, appointment_id text, doctor_id text, record_date timestamp, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals text, created_at timestamp )\nCREATE TABLE healthcare.diagnoses (\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 ( medication_id text PRIMARY KEY, 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me all terminated drivers who had worked for the company for more than 5 years before termination."}, {"role": "assistant", "content": "SELECT driver_id, first_name, last_name, hire_date FROM transportation.drivers WHERE status = 'Terminated' AND (hire_date < (CURRENT_DATE - INTERVAL '5 years'));"}, {"role": "user", "content": "Can you include their license numbers and calculate how many years they worked before termination?"}, {"role": "assistant", "content": "SELECT driver_id, first_name, last_name, license_number, hire_date, EXTRACT(YEAR FROM AGE(CURRENT_DATE, hire_date)) AS years_worked FROM transportation.drivers WHERE status = 'Terminated' AND (hire_date < (CURRENT_DATE - INTERVAL '5 years'));"}, {"role": "user", "content": "Now order the results by years worked in descending order, showing those who worked the longest first."}, {"role": "assistant", "content": "SELECT driver_id, first_name, last_name, license_number, hire_date, EXTRACT(YEAR FROM AGE(CURRENT_DATE, hire_date)) AS years_worked FROM transportation.drivers WHERE status = 'Terminated' AND (hire_date < (CURRENT_DATE - INTERVAL '5 years')) ORDER BY years_worked 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.drivers (\n    driver_id character varying(64) NOT NULL,  -- unique identifier for the driver\n    employee_id character varying(64) NOT NULL UNIQUE, -- employee reference number\n    first_name character varying(128) NOT NULL, -- driver's first name\n    last_name character varying(128) NOT NULL, -- driver's last name\n    license_number character varying(64) NOT NULL UNIQUE, -- driving license number\n    license_expiry_date date NOT NULL, -- expiry date of the license\n    contact_number character varying(32), -- phone number\n    email character varying(128) UNIQUE, -- email address\n    hire_date date NOT NULL, -- date the driver was hired\n    status character varying(32) NOT NULL, -- e.g., Active, On Leave, Terminated\n    PRIMARY KEY (driver_id)\n)\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": "How many documents of each type exist in the system? Show the document type and the count."}, {"role": "assistant", "content": "SELECT document_type, COUNT(*) AS document_count\nFROM legal_services.documents\ngroup BY document_type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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.documents ( document_id text, case_id text, document_name text, document_type text, storage_path text, uploaded_by_lawyer_id text, upload_timestamp timestamp, version integer, description text )\nCREATE TABLE legal_services.time_entries ( 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": "How many documents were uploaded in the year 2023?"}, {"role": "assistant", "content": "SELECT count(*) FROM government_services.documents WHERE date_part('year', upload_timestamp) = 2023;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.documents ( document_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, document_type character varying(100) NOT NULL, file_reference text NOT NULL, upload_timestamp timestamp NOT NULL, expiry_date date, verification_status character varying(30) DEFAULT 'Pending', verified_by_employee_id character varying(64), verification_timestamp timestamp, PRIMARY KEY (document_id) )\n"}
{"conversations": [{"role": "user", "content": "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": "Summarize trade activity by account and execution venue, showing the total quantity of shares traded and the average commission paid."}, {"role": "assistant", "content": "SELECT account_id, execution_venue, SUM(quantity) AS total_quantity, AVG(commission) AS average_commission FROM financial_services.trades GROUP BY account_id, execution_venue;"}, {"role": "user", "content": "Refine that report to only include trades where the total_amount for a single trade was greater than 5000. Also, only show account/venue groups where the total quantity traded is at least 100."}, {"role": "assistant", "content": "SELECT account_id, execution_venue, SUM(quantity) AS total_quantity, AVG(commission) AS average_commission FROM financial_services.trades WHERE total_amount > 5000 GROUP BY account_id, execution_venue HAVING SUM(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 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": "List the token symbol, token name, and contract address for all tokens that have no recorded transfers in the token_transfers table."}, {"role": "assistant", "content": "SELECT T.token_symbol, T.token_name, T.contract_address FROM web3.tokens AS T LEFT JOIN token_transfers AS TT ON T.token_id = TT.token_id WHERE TT.transfer_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 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)\n"}
{"conversations": [{"role": "user", "content": "List the latest version of each document (identified by case_id and document_name), showing the version number and its upload_timestamp."}, {"role": "assistant", "content": "SELECT d.case_id,\n       d.document_name,\n       d.version   AS latest_version,\n       d.upload_timestamp\nFROM legal_services.documents d\nJOIN (\n  SELECT case_id, document_name, MAX(version) AS max_version\n  FROM legal_services.documents\n  GROUP BY case_id, document_name\n) m ON d.case_id = m.case_id\n    AND d.document_name = m.document_name\n    AND d.version = m.max_version;"}, {"role": "user", "content": "Actually, I also want to see the upload_timestamp of the previous version for each document."}, {"role": "assistant", "content": "SELECT m.case_id,\n       m.document_name,\n       m.max_version         AS latest_version,\n       d_latest.upload_timestamp  AS latest_timestamp,\n       d_prev.upload_timestamp    AS previous_timestamp\nFROM (\n  SELECT case_id, document_name, MAX(version) AS max_version\n  FROM legal_services.documents\n  GROUP BY case_id, document_name\n) m\nJOIN legal_services.documents d_latest\n  ON d_latest.case_id = m.case_id\n AND d_latest.document_name = m.document_name\n AND d_latest.version = m.max_version\nLEFT JOIN legal_services.documents d_prev\n  ON d_prev.case_id = m.case_id\n AND d_prev.document_name = m.document_name\n AND d_prev.version = m.max_version - 1;"}, {"role": "user", "content": "Also, only include documents whose first version (version = 1) was uploaded in 2024."}, {"role": "assistant", "content": "SELECT m.case_id,\n       m.document_name,\n       m.max_version          AS latest_version,\n       d_latest.upload_timestamp   AS latest_timestamp,\n       d_prev.upload_timestamp     AS previous_timestamp\nFROM (\n  SELECT case_id, document_name, MAX(version) AS max_version\n  FROM legal_services.documents\n  GROUP BY case_id, document_name\n) m\nJOIN legal_services.documents d_first\n  ON d_first.case_id = m.case_id\n AND d_first.document_name = m.document_name\n AND d_first.version = 1\n AND d_first.upload_timestamp >= '2024-01-01'\n AND d_first.upload_timestamp < '2025-01-01'\nJOIN legal_services.documents d_latest\n  ON d_latest.case_id = m.case_id\n AND d_latest.document_name = m.document_name\n AND d_latest.version = m.max_version\nLEFT JOIN legal_services.documents d_prev\n  ON d_prev.case_id = m.case_id\n AND d_prev.document_name = m.document_name\n AND d_prev.version = m.max_version - 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 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 me all premium payments made in Q1 2023, along with their payment methods and amounts, sorted by payment date."}, {"role": "assistant", "content": "SELECT payment_method, amount_paid, payment_date FROM insurance.premium_payments WHERE payment_date BETWEEN '2023-01-01' AND '2023-03-31' ORDER BY payment_date;"}, {"role": "user", "content": "Now break this down by payment method to show the total amount collected per payment method in that quarter."}, {"role": "assistant", "content": "SELECT payment_method, SUM(amount_paid) AS total_amount FROM insurance.premium_payments WHERE payment_date BETWEEN '2023-01-01' AND '2023-03-31' GROUP BY payment_method ORDER BY total_amount DESC;"}, {"role": "user", "content": "I also want to see the average payment amount for each payment method in Q1 2023."}, {"role": "assistant", "content": "SELECT payment_method, AVG(amount_paid) AS average_payment FROM insurance.premium_payments WHERE payment_date BETWEEN '2023-01-01' AND '2023-03-31' GROUP BY payment_method ORDER BY average_payment DESC;"}, {"role": "user", "content": "Finally, show me only payment methods where the average payment was greater than $300."}, {"role": "assistant", "content": "SELECT payment_method, AVG(amount_paid) AS average_payment FROM insurance.premium_payments WHERE payment_date BETWEEN '2023-01-01' AND '2023-03-31' GROUP BY payment_method HAVING AVG(amount_paid) > 300 ORDER BY average_payment 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.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) )\n"}
{"conversations": [{"role": "user", "content": "I want to find the total number of ERC1155 \"approval-for-all\" events per contract. Show contract_address and the approval_count."}, {"role": "assistant", "content": "SELECT contract_address, COUNT(*) AS approval_count\nFROM erc1155_approval_for_all\nGROUP BY contract_address;"}, {"role": "user", "content": "Also show the number of unique wallet holders currently holding any token from those contracts by joining to nft_holders."}, {"role": "assistant", "content": "SELECT a.contract_address,\n       a.approval_count,\n       COALESCE(b.holder_count, 0) AS holder_count\nFROM (\n  SELECT contract_address, COUNT(*) AS approval_count\n  FROM erc1155_approval_for_all\n  GROUP BY contract_address\n) a\nLEFT JOIN (\n  SELECT contract_address, COUNT(DISTINCT wallet_address) AS holder_count\n  FROM nft_holders\n  GROUP BY contract_address\n) b\n  ON a.contract_address = b.contract_address;"}, {"role": "user", "content": "Filter to only include contracts where holder_count is greater than 50."}, {"role": "assistant", "content": "SELECT a.contract_address,\n       a.approval_count,\n       b.holder_count\nFROM (\n  SELECT contract_address, COUNT(*) AS approval_count\n  FROM erc1155_approval_for_all\n  GROUP BY contract_address\n) a\nJOIN (\n  SELECT contract_address, COUNT(DISTINCT wallet_address) AS holder_count\n  FROM nft_holders\n  GROUP BY contract_address\n  HAVING COUNT(DISTINCT wallet_address) > 50\n) b\n  ON a.contract_address = b.contract_address;"}, {"role": "user", "content": "Sort results by approval_count descending and limit to the top 10."}, {"role": "assistant", "content": "SELECT a.contract_address,\n       a.approval_count,\n       b.holder_count\nFROM (\n  SELECT contract_address, COUNT(*) AS approval_count\n  FROM erc1155_approval_for_all\n  GROUP BY contract_address\n) a\nJOIN (\n  SELECT contract_address, COUNT(DISTINCT wallet_address) AS holder_count\n  FROM nft_holders\n  GROUP BY contract_address\n  HAVING COUNT(DISTINCT wallet_address) > 50\n) b\n  ON a.contract_address = b.contract_address\nORDER BY a.approval_count DESC\nLIMIT 10;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE token_metas ( block_timestamp timestamp, block_number bigint, transaction_hash 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, block_timestamp timestamp, transaction_index integer, transaction_hash varchar, log_index integer, contract_address varchar )\nCREATE TABLE erc20_balances_historical ( block_number.bigint, contract_address.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_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 (\n    blockchain varchar NOT NULL, -- blockchain fields for the functionType  in contract\n    contract_address varchar NOT NULL, -- Contract address(with bloom filter)\n    token_id varchar NOT NULL, -- The number of the token\n    contract_name varchar NOT NULL, -- contract_name fields for the functionType  in contract\n    erc_type varchar NOT NULL, -- The type of token\n    amount bigint NOT NULL, -- amount fields for the functionType  in contract\n    minter varchar NOT NULL, -- minter fields for the functionType  in contract\n    owner varchar NOT NULL, -- owner fields for the functionType  in contract\n    mint_block_number bigint NOT NULL, -- mint_block_number fields for the functionType  in contract\n    mint_time bigint NOT NULL, -- mint_time fields for the functionType  in contract\n    mint_transaction_hash varchar NOT NULL, -- mint_transaction_hash fields for the functionType  in contract\n    mint_price varchar NOT NULL, -- mint_price fields for the functionType  in contract\n    token_uri varchar NOT NULL, -- token_uri fields for the functionType  in contract\n    metadata varchar NOT NULL, -- metadata fields for the functionType  in contract\n    name varchar NOT NULL, -- name fields for the functionType  in contract\n    image_uri varchar NOT NULL, -- image_uri fields for the functionType  in contract\n    traits varchar NOT NULL, -- traits fields for the functionType  in contract\n    updated_at bigint NOT NULL, -- updated_at fields for the functionType  in contract\n    status varchar NOT NULL, -- status fields for the functionType  in contract\n    rarity_score real NOT NULL, -- rarity_score fields for the functionType  in contract\n    rarity_rank integer NOT NULL, -- rarity_rank fields for the functionType  in contract\n    unique_attribute_count integer NOT NULL, -- unique_attribute_count fields for the functionType  in contract\n    pk integer NOT NULL  -- Partition key for the table(floor(mint_time / 1000 / 86400 / 30))\n)\nCREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )\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, block_number bigint, tx_index integer, tx_hash text, tick text, max_supply decimal, lim decimal, wlim decimal, dec integer, creator text )\nCREATE TABLE token_activities_avalanche ( block_timestamp timestamp(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 )\n"}
{"conversations": [{"role": "user", "content": "For each user, show their user_id, KYC status, and the total count of completed orders they've placed."}, {"role": "assistant", "content": "SELECT k.user_id, k.status, COUNT(o.order_id) AS completed_order_count\nFROM trading_platform.kyc_audit k\nJOIN trading_platform.orders o\n  ON k.user_id = o.user_id\n  AND o.status = 'completed'\nGROUP BY k.user_id, k.status;"}, {"role": "user", "content": "Only include users whose KYC status is 'approved'."}, {"role": "assistant", "content": "SELECT k.user_id, k.status, COUNT(o.order_id) AS completed_order_count\nFROM trading_platform.kyc_audit k\nJOIN trading_platform.orders o\n  ON k.user_id = o.user_id\n  AND o.status = 'completed'\nWHERE k.status = 'approved'\nGROUP BY k.user_id, k.status;"}, {"role": "user", "content": "Also calculate the total value of these completed orders as total_value."}, {"role": "assistant", "content": "SELECT k.user_id,\n       k.status,\n       COUNT(o.order_id) AS completed_order_count,\n       SUM(o.quantity * o.price) AS total_value\nFROM trading_platform.kyc_audit k\nJOIN trading_platform.orders o\n  ON k.user_id = o.user_id\n  AND o.status = 'completed'\nWHERE k.status = 'approved'\nGROUP BY k.user_id, k.status;"}, {"role": "user", "content": "Finally, order the results by total_value descending and limit to 5."}, {"role": "assistant", "content": "SELECT k.user_id,\n       k.status,\n       COUNT(o.order_id) AS completed_order_count,\n       SUM(o.quantity * o.price) AS total_value\nFROM trading_platform.kyc_audit k\nJOIN trading_platform.orders o\n  ON k.user_id = o.user_id\n  AND o.status = 'completed'\nWHERE k.status = 'approved'\nGROUP BY k.user_id, k.status\nORDER BY total_value 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.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.utxos ( utxo_id text PRIMARY KEY, transaction_id text, output_index int, address text, amount numeric, spent boolean )\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 ( log_id character varying(64) NOT NULL, user_id character varying(64), action character varying(128) NOT NULL, details text NOT NULL, logged_at timestamp NOT NULL, PRIMARY KEY (log_id) )\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 all intercity routes that have an estimated duration of more than 2 hours, along with their origin and destination locations."}, {"role": "assistant", "content": "SELECT r.route_id, r.route_number, r.estimated_duration_minutes, lo.name AS origin_location, ld.name AS destination_location FROM transportation.routes r JOIN transportation.locations lo ON r.origin_location_id = lo.location_id JOIN transportation.locations ld ON r.destination_location_id = ld.location_id WHERE r.type = 'Intercity Train' AND r.estimated_duration_minutes > 120 ORDER BY r.estimated_duration_minutes DESC;"}, {"role": "user", "content": "Can you include the distance in kilometers and filter to only show routes longer than 100 km?"}, {"role": "assistant", "content": "SELECT r.route_id, r.route_number, r.distance_km, r.estimated_duration_minutes, lo.name AS origin_location, ld.name AS destination_location FROM transportation.routes r JOIN transportation.locations lo ON r.origin_location_id = lo.location_id JOIN transportation.locations ld ON r.destination_location_id = ld.location_id WHERE r.type = 'Intercity Train' AND r.estimated_duration_minutes > 120 AND r.distance_km > 100 ORDER BY r.distance_km DESC;"}, {"role": "user", "content": "Now show me the average passenger count for trips on these routes in the last month."}, {"role": "assistant", "content": "SELECT r.route_id, r.route_number, AVG(t.passenger_count) AS average_passengers FROM transportation.routes r JOIN transportation.trips t ON r.route_id = t.route_id WHERE r.type = 'Intercity Train' AND r.estimated_duration_minutes > 120 AND r.distance_km > 100 AND t.actual_departure >= (CURRENT_DATE - INTERVAL '1 month') GROUP BY r.route_id, r.route_number ORDER BY average_passengers 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.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 (\n    route_id character varying(64) NOT NULL,  -- unique identifier for the route\n    route_number character varying(32) NOT NULL UNIQUE, -- public-facing route number/name\n    description text, -- description of the route\n    origin_location_id character varying(64) NOT NULL, -- identifier of the starting location\n    destination_location_id character varying(64) NOT NULL, -- identifier of the ending location\n    distance_km numeric(10, 2), -- estimated distance in kilometers\n    estimated_duration_minutes integer, -- estimated travel time in minutes\n    type character varying(32) NOT NULL, -- e.g., City Bus, Intercity Train, Cargo Delivery\n    PRIMARY KEY (route_id)\n)\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 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 (\n    log_id character varying(64) NOT NULL,  -- unique identifier for the maintenance record\n    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle serviced\n    service_date date NOT NULL, -- date the service was performed\n    odometer_reading integer, -- vehicle mileage at time of service\n    service_type character varying(128) NOT NULL, -- type of service (e.g., Oil Change, Tire Rotation, Engine Repair)\n    description text NOT NULL, -- detailed description of work done\n    cost numeric(10, 2), -- cost of the service\n    mechanic_name character varying(128), -- name or ID of the mechanic/shop\n    next_service_due_date date, -- recommended date for next service\n    PRIMARY KEY (log_id)\n)\nCREATE TABLE transportation.fuel_logs ( fuel_log_id.text, vehicle_id.text, trip_id.text, log_timestamp.timestamp, fuel_type.text, quantity.numeric, unit.text, cost_per_unit.numeric, total_cost.numeric, odometer_reading.integer, location_id.text )\nCREATE TABLE transportation.passengers (\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": "List all pairs of properties located in the same city, showing each pair's property IDs and names along with the city."}, {"role": "assistant", "content": "SELECT p1.property_id AS property_id_1,\n       p1.property_name AS property_name_1,\n       p2.property_id AS property_id_2,\n       p2.property_name AS property_name_2,\n       p1.city\nFROM hospitality_technology.properties p1\nJOIN hospitality_technology.properties p2\n  ON p1.city = p2.city\n AND p1.property_id < p2.property_id;"}, {"role": "user", "content": "Only include pairs in cities that have more than two properties."}, {"role": "assistant", "content": "SELECT p1.property_id AS property_id_1,\n       p1.property_name AS property_name_1,\n       p2.property_id AS property_id_2,\n       p2.property_name AS property_name_2,\n       p1.city\nFROM hospitality_technology.properties p1\nJOIN hospitality_technology.properties p2\n  ON p1.city = p2.city\n AND p1.property_id < p2.property_id\nWHERE p1.city IN (\n  SELECT city\n  FROM hospitality_technology.properties\n  GROUP BY city\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.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) )\n"}
{"conversations": [{"role": "user", "content": "Show all tokens on the 'Arbitrum' chain from DEX pools that have a 24-hour trading volume between $100,000 and $500,000. Display token symbol, price, and volume_24h."}, {"role": "assistant", "content": "SELECT\n  token_symbol,\n  price,\n  volume_24h\nFROM token_dexpool_info\nWHERE\n  chain = 'Arbitrum' AND volume_24h BETWEEN 100000 AND 500000;"}, {"role": "user", "content": "Include their liquidity and 6-hour price change percentage in the results."}, {"role": "assistant", "content": "SELECT\n  token_symbol,\n  price,\n  volume_24h,\n  liquidity,\n  price_change_percentage_6h\nFROM token_dexpool_info\nWHERE\n  chain = 'Arbitrum' AND volume_24h BETWEEN 100000 AND 500000;"}], "system": "You are an SQL statement expert. Given the table structure 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_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) )\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": "Show all transactions over 10,000 USD that are not marked as 'REVERSED'."}, {"role": "assistant", "content": "SELECT transaction_id, account_id, amount, currency, status, transaction_date\nFROM financial_services.transactions\nWHERE amount > 10000 AND currency = 'USD' AND status != 'REVERSED';"}, {"role": "user", "content": "Include the related_account_id and the transaction_type in the result, and order by amount descending."}, {"role": "assistant", "content": "SELECT transaction_id, account_id, related_account_id, transaction_type, amount, currency, status, transaction_date\nFROM financial_services.transactions\nWHERE amount > 10000 AND currency = 'USD' AND status != 'REVERSED'\nORDER BY amount DESC;"}, {"role": "user", "content": "Add a filter to only include transactions that happened in the last 60 days."}, {"role": "assistant", "content": "SELECT transaction_id, account_id, related_account_id, transaction_type, amount, currency, status, transaction_date\nFROM financial_services.transactions\nWHERE amount > 10000 AND currency = 'USD' AND status != 'REVERSED' AND transaction_date >= NOW() - INTERVAL '60 days'\nORDER BY 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 ( customer_id text, first_name text, last_name text, date_of_birth date, ssn_hash text, address text, city text, state text, zip_code text, country text, email text, phone_number text, created_at timestamp, status text, risk_profile text )\nCREATE TABLE financial_services.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 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 (\n    employee_id character varying(64) NOT NULL,  -- unique identifier for the employee\n    first_name character varying(100) NOT NULL,\n    last_name character varying(100) NOT NULL,\n    job_title character varying(100) NOT NULL, -- e.g., Teller, Branch Manager, Financial Advisor, Analyst\n    department character varying(100), -- e.g., Retail Banking, Wealth Management, IT\n    branch_id character varying(64), -- Identifier for the branch they work at (if applicable)\n    email character varying(128) NOT NULL UNIQUE,\n    phone_extension character varying(20),\n    hire_date date NOT NULL,\n    termination_date date, -- Date of termination, null if currently employed\n    manager_id character varying(64), -- Self-referencing key for manager relationship\n    status character varying(32) NOT NULL, -- e.g., Active, Terminated, On Leave\n    PRIMARY KEY (employee_id),\n    FOREIGN KEY (branch_id) REFERENCES financial_services.branches(branch_id), -- Assuming a branches table exists\n    FOREIGN KEY (manager_id) REFERENCES financial_services.employees(employee_id)\n)\n"}
{"conversations": [{"role": "user", "content": "List all wallets that were created during the hour of the day which saw the highest number of wallet creations. Show the wallet ID, user ID, address, and creation timestamp."}, {"role": "assistant", "content": "WITH HourlyCounts AS (\n    SELECT EXTRACT(HOUR FROM created_at) AS hour, COUNT(*) AS wallet_count\n    FROM web3.wallets\n    GROUP BY 1\n),\nMaxHour AS (\n    SELECT hour\n    FROM HourlyCounts\n    ORDER BY wallet_count DESC\n    LIMIT 1\n)\nSELECT wallet_id, user_id, address, created_at\nFROM web3.wallets\nWHERE EXTRACT(HOUR FROM created_at) = (SELECT hour FROM MaxHour);"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE web3.wallets ( wallet_id text PRIMARY KEY, user_id text, address text, private_key text, created_at timestamp )\n"}
{"conversations": [{"role": "user", "content": "List all active SUI coins with their symbol, name, and total balance across all owners."}, {"role": "assistant", "content": "SELECT scm.coin_type, scm.symbol, scm.name, SUM(CAST(sc.balance AS DECIMAL)) AS total_balance\nFROM sui_coins_metadata scm\nJOIN sui_coins sc ON sc.coin_type = scm.coin_type\nWHERE sc.status = 'active' AND scm.status = 'exists'\nGROUP BY scm.coin_type, scm.symbol, scm.name;"}, {"role": "user", "content": "Filter coins with description containing 'staking' and sort by total_balance descending."}, {"role": "assistant", "content": "SELECT sub.coin_type, sub.symbol, sub.name, sub.total_balance\nFROM (\n  SELECT scm.coin_type, scm.symbol, scm.name, SUM(CAST(sc.balance AS DECIMAL)) AS total_balance\n  FROM sui_coins_metadata scm\n  JOIN sui_coins sc ON sc.coin_type = scm.coin_type\n  WHERE sc.status = 'active' AND scm.status = 'exists' AND LOWER(scm.description) LIKE '%staking%'\n  GROUP BY scm.coin_type, scm.symbol, scm.name\n) sub\nORDER BY sub.total_balance DESC;"}, {"role": "user", "content": "Limit the result to the top 3 coins."}, {"role": "assistant", "content": "SELECT sub.coin_type, sub.symbol, sub.name, sub.total_balance\nFROM (\n  SELECT scm.coin_type, scm.symbol, scm.name, SUM(CAST(sc.balance AS DECIMAL)) AS total_balance\n  FROM sui_coins_metadata scm\n  JOIN sui_coins sc ON sc.coin_type = scm.coin_type\n  WHERE sc.status = 'active' AND scm.status = 'exists' AND LOWER(scm.description) LIKE '%staking%'\n  GROUP BY scm.coin_type, scm.symbol, scm.name\n) sub\nORDER BY sub.total_balance 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 token_metas ( block_timestamp.timestamp, block_number.bigint, transaction_hash.text, transaction_index.bigint, from_address.text, contract_address.text, symbol.text, total_supply.text, name.text, decimals.bigint, is_erc20.integer, is_erc721.integer, is_erc1155.integer, is_proxy.integer, extra_info.text, pk.integer )\nCREATE TABLE erc1155_approval_for_all (\n    block_number bigint NOT NULL, -- Block number containing the transaction\n    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction\n    transaction_index integer NOT NULL, -- Index of the transaction within the block\n    transaction_hash varchar(66) NOT NULL, -- Transaction hash\n    log_index integer NOT NULL, -- Log index\n    contract_address varchar(42) NOT NULL  -- Event contract address\n)\nCREATE TABLE erc20_balances ( block_number bigint, contract_address varchar, wallet_address varchar, amount varchar, pk varchar )\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 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 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_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": "Return the number of top-level comments and the number of replies in the comments table."}, {"role": "assistant", "content": "SELECT\n  SUM(CASE WHEN parent_comment_id IS NULL THEN 1 ELSE 0 END) AS top_level_comments,\n  SUM(CASE WHEN parent_comment_id IS NOT NULL THEN 1 ELSE 0 END) AS reply_comments\nFROM social_media.comments;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE social_media.users ( user_id text, username text, email text, password_hash text, full_name text, profile_picture_url text, bio text, location text, created_at timestamp, updated_at timestamp, is_verified boolean )\nCREATE TABLE social_media.posts ( post_id text, user_id text, content text, media_url text, media_type text, created_at timestamp, updated_at timestamp, visibility text, location_lat numeric, location_lon numeric )\nCREATE TABLE social_media.comments ( comment_id text, post_id text, user_id text, parent_comment_id text, content text, created_at timestamp, updated_at timestamp )\nCREATE TABLE social_media.follows ( follow_id text, follower_user_id text, following_user_id text, created_at timestamp )\nCREATE TABLE social_media.post_hashtags ( post_hashtag_id text, post_id text, hashtag_id text )\nCREATE TABLE social_media.conversations ( conversation_id text, created_at timestamp, last_message_at timestamp, is_group_chat boolean, group_name text )\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": "Find all pairs of distinct medications manufactured by the same company, showing med1.medication_id, med1.medication_name, med2.medication_id, med2.medication_name, and the manufacturer."}, {"role": "assistant", "content": "SELECT m1.medication_id AS med1_id, m1.medication_name AS med1_name, m2.medication_id AS med2_id, m2.medication_name AS med2_name, m1.manufacturer\nFROM healthcare.medications m1\nJOIN healthcare.medications m2\n  ON m1.manufacturer = m2.manufacturer\n AND m1.medication_id <> m2.medication_id;"}, {"role": "user", "content": "Actually, exclude duplicate pairs by ensuring med1_id is less than med2_id."}, {"role": "assistant", "content": "SELECT m1.medication_id AS med1_id, m1.medication_name AS med1_name, m2.medication_id AS med2_id, m2.medication_name AS med2_name, m1.manufacturer\nFROM healthcare.medications m1\nJOIN healthcare.medications m2\n  ON m1.manufacturer = m2.manufacturer\n AND m1.medication_id < m2.medication_id;"}, {"role": "user", "content": "Also, sort the results by manufacturer ascending and then med1_id ascending."}, {"role": "assistant", "content": "SELECT m1.medication_id AS med1_id, m1.medication_name AS med1_name, m2.medication_id AS med2_id, m2.medication_name AS med2_name, m1.manufacturer\nFROM healthcare.medications m1\nJOIN healthcare.medications m2\n  ON m1.manufacturer = m2.manufacturer\n AND m1.medication_id < m2.medication_id\nORDER BY m1.manufacturer ASC, m1.medication_id 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.medications ( medication_id.text, medication_name.text, generic_name.text, manufacturer.text, ndc_code.text, description.text )\n"}
{"conversations": [{"role": "user", "content": "Can you show me the number of servers in each region, as well as the total max_players for each region?"}, {"role": "assistant", "content": "SELECT region, COUNT(*) AS server_count, SUM(max_players) AS total_max_players FROM gaming_technology.servers GROUP BY region;"}, {"role": "user", "content": "Actually, can you also include the average number of current players per region?"}, {"role": "assistant", "content": "SELECT region, COUNT(*) AS server_count, SUM(max_players) AS total_max_players, AVG(current_players) AS avg_current_players FROM gaming_technology.servers GROUP BY region;"}], "system": "You are an SQL statement expert. Given the table structure 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, 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 )\n"}
{"conversations": [{"role": "user", "content": "Show me all vehicles that are currently out of service (status = 'out_of_service'), including their make, model, and the reason (type field)."}, {"role": "assistant", "content": "SELECT vehicle_id, make, model, type FROM transportation.vehicles WHERE status = 'out_of_service';"}, {"role": "user", "content": "Now include the depot_id and filter to only show vehicles that were acquired more than 3 years ago."}, {"role": "assistant", "content": "SELECT vehicle_id, make, model, type, depot_id FROM transportation.vehicles WHERE status = 'out_of_service' AND acquisition_date < CURRENT_DATE - INTERVAL '3 years';"}, {"role": "user", "content": "Can you also include the fuel_type and order the results by acquisition_date with the oldest vehicles first?"}, {"role": "assistant", "content": "SELECT vehicle_id, make, model, type, depot_id, fuel_type, acquisition_date FROM transportation.vehicles WHERE status = 'out_of_service' AND acquisition_date < CURRENT_DATE - INTERVAL '3 years' ORDER BY acquisition_date ASC;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE transportation.vehicles ( vehicle_id 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": "Can you list the number of citizens registered each month in 2024? Please show the month and the citizen count."}, {"role": "assistant", "content": "SELECT TO_CHAR(registration_date, 'YYYY-MM') AS registration_month, COUNT(*) AS citizen_count FROM government_services.citizens WHERE registration_date >= '2024-01-01' AND registration_date < '2025-01-01' GROUP BY registration_month ORDER BY registration_month;"}, {"role": "user", "content": "Now, can you also show the number of verified citizens for each month?"}, {"role": "assistant", "content": "SELECT TO_CHAR(registration_date, 'YYYY-MM') AS registration_month, COUNT(*) AS citizen_count, SUM(CASE WHEN is_verified = true THEN 1 ELSE 0 END) AS verified_citizen_count FROM government_services.citizens WHERE registration_date >= '2024-01-01' AND registration_date < '2025-01-01' GROUP BY registration_month ORDER BY registration_month;"}, {"role": "user", "content": "I see some months with zero verified citizens, but they still show up. Can you exclude months with zero verified citizens from the result?"}, {"role": "assistant", "content": "SELECT registration_month, citizen_count, verified_citizen_count FROM (SELECT TO_CHAR(registration_date, 'YYYY-MM') AS registration_month, COUNT(*) AS citizen_count, SUM(CASE WHEN is_verified = true THEN 1 ELSE 0 END) AS verified_citizen_count FROM government_services.citizens WHERE registration_date >= '2024-01-01' AND registration_date < '2025-01-01' GROUP BY registration_month) sub WHERE verified_citizen_count > 0 ORDER BY registration_month;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.citizens ( citizen_id character varying(64) NOT NULL, national_id_number character varying(128) NOT NULL UNIQUE, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, date_of_birth date NOT NULL, gender character varying(20), primary_address text NOT NULL, contact_email character varying(128) UNIQUE, contact_phone character varying(32), registration_date timestamp NOT NULL, is_verified boolean DEFAULT false, PRIMARY KEY (citizen_id) )\n"}
{"conversations": [{"role": "user", "content": "Show the plan name and insurance provider for all insurance plans along with the total number of unique patients enrolled in each plan."}, {"role": "assistant", "content": "SELECT ip.plan_name, ip.insurance_provider, COUNT(DISTINCT pi.patient_id) AS enrolled_patient_count\nFROM healthcare.insurance_plans ip\nJOIN healthcare.patients_insurance pi ON ip.plan_id = pi.plan_id\nGROUP BY ip.plan_name, ip.insurance_provider;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.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.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.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 PRIMARY KEY, patient_id text, appointment_id text, doctor_id text, record_date timestamp, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals text, created_at timestamp )\nCREATE TABLE healthcare.diagnoses ( diagnosis_id 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.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": "What is the total revenue generated for each department from delivered service orders? Return department and total_revenue."}, {"role": "assistant", "content": "SELECT s.department,\n       SUM(so.total_price) AS total_revenue\nFROM hospitality_technology.service_orders so\nJOIN hospitality_technology.services s ON so.service_id = s.service_id\nWHERE so.status = 'Delivered'\nGROUP BY s.department;"}, {"role": "user", "content": "Now limit to service orders delivered in the last month and only include departments with total_revenue > 1000."}, {"role": "assistant", "content": "SELECT s.department,\n       SUM(so.total_price) AS total_revenue\nFROM hospitality_technology.service_orders so\nJOIN hospitality_technology.services s ON so.service_id = s.service_id\nWHERE so.status = 'Delivered'\n  AND so.delivery_timestamp >= date_trunc('month', current_date - INTERVAL '1 month')\n  AND so.delivery_timestamp < date_trunc('month', current_date)\nGROUP BY s.department\nHAVING SUM(so.total_price) > 1000;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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.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, 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.reviews ( review_id text, property_id text, reservation_id text, guest_id text, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source text, review_date timestamp, is_public boolean, staff_response text, response_staff_id text, response_date timestamp )\n"}
{"conversations": [{"role": "user", "content": "Find all appointments at location_id 'LOC123' where the reason contains 'follow-up' and the status is 'Scheduled', showing appointment_time and patient_id."}, {"role": "assistant", "content": "SELECT appointment_time, patient_id FROM healthcare.appointments WHERE location_id = 'LOC123' AND reason LIKE '%follow-up%' AND 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.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": "Find pairs of insurance policies where the plan_id is the same, but they belong to different patients. Show the plan_id, and the patient_id and policy_number for both policies in the pair."}, {"role": "assistant", "content": "SELECT T1.plan_id, T1.patient_id AS patient_id_1, T1.policy_number AS policy_number_1, T2.patient_id AS patient_id_2, T2.policy_number AS policy_number_2 FROM healthcare.patient_insurance AS T1 JOIN healthcare.patient_insurance AS T2 ON T1.plan_id = T2.plan_id WHERE T1.patient_id <> T2.patient_id AND T1.patient_insurance_id < T2.patient_insurance_id;"}, {"role": "user", "content": "Refine this to only include policies that are currently active (expiration_date IS NULL or > CURRENT_DATE) for both policies in the pair."}, {"role": "assistant", "content": "SELECT T1.plan_id, T1.patient_id AS patient_id_1, T1.policy_number AS policy_number_1, T2.patient_id AS patient_id_2, T2.policy_number AS policy_number_2 FROM healthcare.patient_insurance AS T1 JOIN healthcare.patient_insurance AS T2 ON T1.plan_id = T2.plan_id WHERE T1.patient_id <> T2.patient_id AND T1.patient_insurance_id < T2.patient_insurance_id AND (T1.expiration_date IS NULL OR T1.expiration_date > CURRENT_DATE) AND (T2.expiration_date IS NULL OR T2.expiration_date > CURRENT_DATE);"}, {"role": "user", "content": "Also, only show pairs where one policy is primary and the other is not primary (is_primary = TRUE for one, is_primary = FALSE for the other)."}, {"role": "assistant", "content": "SELECT T1.plan_id, T1.patient_id AS patient_id_1, T1.policy_number AS policy_number_1, T2.patient_id AS patient_id_2, T2.policy_number AS policy_number_2 FROM healthcare.patient_insurance AS T1 JOIN healthcare.patient_insurance AS T2 ON T1.plan_id = T2.plan_id WHERE T1.patient_id <> T2.patient_id AND T1.patient_insurance_id < T2.patient_insurance_id AND (T1.expiration_date IS NULL OR T1.expiration_date > CURRENT_DATE) AND (T2.expiration_date IS NULL OR T2.expiration_date > CURRENT_DATE) AND ((T1.is_primary = TRUE AND T2.is_primary = FALSE) OR (T1.is_primary = FALSE AND T2.is_primary = TRUE));"}, {"role": "user", "content": "Filter further to only show pairs where the shared plan_id starts with 'HMO'."}, {"role": "assistant", "content": "SELECT T1.plan_id, T1.patient_id AS patient_id_1, T1.policy_number AS policy_number_1, T2.patient_id AS patient_id_2, T2.policy_number AS policy_number_2 FROM healthcare.patient_insurance AS T1 JOIN healthcare.patient_insurance AS T2 ON T1.plan_id = T2.plan_id WHERE T1.patient_id <> T2.patient_id AND T1.patient_insurance_id < T2.patient_insurance_id AND (T1.expiration_date IS NULL OR T1.expiration_date > CURRENT_DATE) AND (T2.expiration_date IS NULL OR T2.expiration_date > CURRENT_DATE) AND ((T1.is_primary = TRUE AND T2.is_primary = FALSE) OR (T1.is_primary = FALSE AND T2.is_primary = TRUE)) AND T1.plan_id LIKE 'HMO%';"}], "system": "You are an SQL statement expert. Given the table structure 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 ( 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": "Please provide each follow relationship, including the follower's username, the followed user's username, and the follow creation timestamp."}, {"role": "assistant", "content": "SELECT\n  u1.username AS follower_username,\n  u2.username AS following_username,\n  f.created_at AS follow_date\nFROM\n  social_media.follows f\n  JOIN social_media.users u1 ON f.follower_user_id = u1.user_id\n  JOIN social_media.users u2 ON f.following_user_id = u2.user_id;"}, {"role": "user", "content": "Actually, I only want follows from the last month and order by the follow date descending."}, {"role": "assistant", "content": "SELECT\n  u1.username AS follower_username,\n  u2.username AS following_username,\n  f.created_at AS follow_date\nFROM\n  social_media.follows f\n  JOIN social_media.users u1 ON f.follower_user_id = u1.user_id\n  JOIN social_media.users u2 ON f.following_user_id = u2.user_id\nWHERE\n  f.created_at >= now() - INTERVAL '1 month'\nORDER BY\n  f.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 ( 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.likes ( like_id text PRIMARY KEY, user_id text, post_id text, comment_id text, created_at timestamp )\nCREATE TABLE social_media.follows ( follow_id text PRIMARY KEY, follower_user_id text, following_user_id text, created_at timestamp )\nCREATE TABLE social_media.conversations ( conversation_id text PRIMARY KEY, created_at timestamp, last_message_at timestamp, is_group_chat bool, group_name text )\n"}
{"conversations": [{"role": "user", "content": "How many addresses on the Polygon chain have an ROI above 5?"}, {"role": "assistant", "content": "SELECT COUNT(*) AS address_count FROM smart_money_profit WHERE chain = 'Polygon' AND roi > 5;"}, {"role": "user", "content": "Also show the average profit of these addresses."}, {"role": "assistant", "content": "SELECT COUNT(*) AS address_count, AVG(profit) AS avg_profit FROM smart_money_profit WHERE chain = 'Polygon' AND roi > 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 smart_money_profit ( address text, rank numeric, profit numeric, roi numeric, realized_ratio numeric, most_profit_token text, last_trade_time text, chain text )\n"}
{"conversations": [{"role": "user", "content": "List all insurance plans along with their provider, plan type, and the contact phone number. Also, for each plan, show how many doctors have their hospital affiliation ID matching the plan ID."}, {"role": "assistant", "content": "SELECT ip.plan_id, ip.plan_name, ip.insurance_provider, ip.plan_type, ip.contact_phone, COUNT(d.doctor_id) FROM healthcare.insurance_plans ip LEFT JOIN healthcare.doctors d ON ip.plan_id = d.hospital_affiliation_id GROUP BY ip.plan_id, ip.plan_name, ip.insurance_provider, ip.plan_type, ip.contact_phone"}], "system": "You are an SQL statement expert. Given the table structure 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.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.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 prescription ID, medication ID, and the record ID for all prescriptions linked to medical records where the chief complaint contains 'cough'."}, {"role": "assistant", "content": "SELECT T1.prescription_id, T1.medication_id, T1.record_id FROM healthcare.prescriptions AS T1 JOIN healthcare.medical_records AS T2 ON T1.record_id = T2.record_id WHERE T2.chief_complaint LIKE '%cough%';"}, {"role": "user", "content": "Add the dosage and quantity dispensed for these prescriptions."}, {"role": "assistant", "content": "SELECT T1.prescription_id, T1.medication_id, T1.record_id, T1.dosage, T1.quantity_dispensed FROM healthcare.prescriptions AS T1 JOIN healthcare.medical_records AS T2 ON T1.record_id = T2.record_id WHERE T2.chief_complaint LIKE '%cough%';"}, {"role": "user", "content": "Instead of record ID, show the record date and the patient's full name."}, {"role": "assistant", "content": "SELECT T1.prescription_id, T1.medication_id, T1.dosage, T1.quantity_dispensed, T2.record_date, T3.first_name, T3.last_name FROM healthcare.prescriptions AS T1 JOIN healthcare.medical_records AS T2 ON T1.record_id = T2.record_id JOIN healthcare.patients AS T3 ON T1.patient_id = T3.patient_id WHERE T2.chief_complaint LIKE '%cough%';"}, {"role": "user", "content": "Now, filter the results to only include prescriptions issued after January 1, 2023, and order by record date."}, {"role": "assistant", "content": "SELECT T1.prescription_id, T1.medication_id, T1.dosage, T1.quantity_dispensed, T2.record_date, T3.first_name, T3.last_name FROM healthcare.prescriptions AS T1 JOIN healthcare.medical_records AS T2 ON T1.record_id = T2.record_id JOIN healthcare.patients AS T3 ON T1.patient_id = T3.patient_id WHERE T2.chief_complaint LIKE '%cough%' AND T1.prescription_date > '2023-01-01' ORDER BY T2.record_date;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE healthcare.patients ( patient_id 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.doctors ( doctor_id text, first_name text, last_name text, specialty text, license_number text, phone_number text, email text, hospital_affiliation_id text, created_at timestamp, updated_at timestamp )\nCREATE TABLE healthcare.medical_records ( record_id text PRIMARY KEY, patient_id text, appointment_id text, doctor_id text, record_date timestamp, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals text, created_at timestamp )\nCREATE TABLE healthcare.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 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": "Show the usernames and registration dates for all players whose status is 'inactive'."}, {"role": "assistant", "content": "SELECT username, registration_date FROM players WHERE status = 'inactive';"}, {"role": "user", "content": "Refine the list to only include players registered after '2023-01-01'."}, {"role": "assistant", "content": "SELECT username, registration_date FROM players WHERE status = 'inactive' AND registration_date >= '2023-01-01';"}, {"role": "user", "content": "Instead, find the number of unique players who registered before '2020-01-01' and have never logged in (last_login is NULL)."}, {"role": "assistant", "content": "SELECT count(player_id) FROM players WHERE registration_date < '2020-01-01' AND last_login IS NULL;"}, {"role": "user", "content": "List the usernames and registration dates for those specific players instead of just the count."}, {"role": "assistant", "content": "SELECT username, registration_date FROM players WHERE registration_date < '2020-01-01' AND last_login 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 gaming_technology.players (\n    player_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the player\n    username character varying(100) NOT NULL UNIQUE, -- player's chosen display name\n    email character varying(255) NOT NULL UNIQUE, -- player's email address for login/recovery\n    password_hash text NOT NULL, -- securely hashed password\n    registration_date timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the player account was created\n    last_login timestamp with time zone, -- timestamp of the last successful login\n    country_code character(2), -- player's country (ISO 3166-1 alpha-2)\n    status character varying(20) NOT NULL DEFAULT 'active', -- account status (e.g., active, banned, suspended)\n    profile_data jsonb, -- flexible field for avatar url, bio, preferences etc.\n    PRIMARY KEY (player_id)\n)\nCREATE TABLE gaming_technology.games (\n    game_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game\n    title character varying(200) NOT NULL, -- official title of the game\n    developer_id uuid NOT NULL, -- FK linking to the developers table\n    publisher_id uuid, -- FK linking to a potential publishers table (optional)\n    genre character varying(100), -- primary genre (e.g., RPG, FPS, Strategy)\n    release_date date, -- official release date\n    description text, -- short description or synopsis of the game\n    platform character varying(50) NOT NULL, -- primary platform (e.g., PC, PlayStation 5, Xbox Series X, Mobile)\n    engine character varying(100), -- game engine used (e.g., Unreal Engine 5, Unity)\n    website character varying(255), -- official website URL\n    PRIMARY KEY (game_id)\n    -- FOREIGN KEY (developer_id) REFERENCES gaming_technology.developers(developer_id) -- Example FK constraint\n)\nCREATE TABLE gaming_technology.game_sessions (\n    session_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game session\n    player_id uuid NOT NULL, -- FK linking to the players table\n    game_id uuid NOT NULL, -- FK linking to the games table\n    server_id uuid, -- FK linking to the servers table (nullable for single-player)\n    start_time timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the session began\n    end_time timestamp with time zone, -- when the session ended (null if ongoing)\n    duration_seconds integer, -- calculated duration of the session in seconds\n    score integer, -- player's score for the session, if applicable\n    session_data jsonb, -- flexible field for session-specific info (e.g., map played, character used)\n    PRIMARY KEY (session_id)\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id),\n    -- FOREIGN KEY (server_id) REFERENCES gaming_technology.servers(server_id)\n)\nCREATE TABLE gaming_technology.servers (\n    server_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game server instance\n    game_id uuid NOT NULL, -- FK linking to the game this server hosts\n    server_name character varying(150), -- display name for the server\n    region character varying(50) NOT NULL, -- geographical region (e.g., us-east-1, eu-west-2)\n    ip_address character varying(45), -- IP address (IPv4 or IPv6)\n    port integer, -- network port number\n    current_players integer NOT NULL DEFAULT 0, -- number of players currently connected\n    max_players integer NOT NULL, -- maximum player capacity\n    status character varying(30) NOT NULL DEFAULT 'offline', -- server status (e.g., online, offline, maintenance)\n    last_heartbeat timestamp with time zone, -- last time the server reported its status\n    PRIMARY KEY (server_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.achievements (\n    achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an achievement definition\n    game_id uuid NOT NULL, -- FK linking to the game the achievement belongs to\n    name character varying(150) NOT NULL, -- name of the achievement\n    description text NOT NULL, -- how to unlock the achievement\n    icon_url character varying(255), -- URL for the achievement's icon\n    points integer DEFAULT 0, -- points awarded for unlocking (optional)\n    hidden boolean DEFAULT false, -- whether the achievement details are hidden until unlocked\n    PRIMARY KEY (achievement_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.player_achievements (\n    player_achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for this unlock instance\n    player_id uuid NOT NULL, -- FK linking to the player who unlocked it\n    achievement_id uuid NOT NULL, -- FK linking to the achievement definition\n    unlocked_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the achievement was unlocked\n    PRIMARY KEY (player_achievement_id),\n    UNIQUE (player_id, achievement_id) -- Ensure a player can only unlock an achievement once\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (achievement_id) REFERENCES gaming_technology.achievements(achievement_id)\n)\nCREATE TABLE gaming_technology.in_game_items (\n    item_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the item definition\n    game_id uuid NOT NULL, -- FK linking to the game this item belongs to\n    item_name character varying(150) NOT NULL, -- name of the item\n    item_type character varying(50) NOT NULL, -- type (e.g., Cosmetic, Consumable, Weapon, Armor)\n    description text, -- description of the item\n    rarity character varying(30), -- item rarity (e.g., Common, Rare, Epic, Legendary)\n    cost_currency character varying(10), -- currency code if purchasable (e.g., USD, EUR, GOLD)\n    cost_amount numeric(12, 2), -- price if purchasable\n    attributes jsonb, -- flexible field for item stats or properties\n    PRIMARY KEY (item_id)\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)\n)\nCREATE TABLE gaming_technology.player_inventory (\n    inventory_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an inventory entry\n    player_id uuid NOT NULL, -- FK linking to the player owning the item\n    item_id uuid NOT NULL, -- FK linking to the item definition\n    quantity integer NOT NULL DEFAULT 1, -- number of items held (for stackable items)\n    acquired_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the item was acquired\n    instance_data jsonb, -- data specific to this instance (e.g., weapon mods, durability)\n    PRIMARY KEY (inventory_id),\n    -- Optional unique constraint if items are non-stackable or unique instances\n    -- UNIQUE (player_id, item_id) -- Use if quantity is always 1\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (item_id) REFERENCES gaming_technology.in_game_items(item_id)\n)\n"}
{"conversations": [{"role": "user", "content": "Show me the total number of sessions and the total duration in seconds for each server, including the server name and the game title."}, {"role": "assistant", "content": "SELECT\n  s.server_name,\n  g.game_title,\n  COUNT(gs.session_id) AS total_sessions,\n  SUM(gs.duration_seconds) AS total_duration_seconds\nFROM gaming_technology.game_sessions AS gs\nJOIN gaming_technology.servers AS s\n  ON gs.server_id = s.server_id\nJOIN gaming_technology.games AS g\n  ON gs.game_id = g.game_id\nGROUP BY\n  s.server_id,\n  s.server_name,\n  g.game_title;"}, {"role": "user", "content": "Actually, I got an error that the table 'games' does not exist. Can you provide the same information but without using the 'games' table? Just show the server name and its game_id."}, {"role": "assistant", "content": "SELECT\n  s.server_name,\n  s.game_id,\n  COUNT(gs.session_id) AS total_sessions,\n  SUM(gs.duration_seconds) AS total_duration_seconds\nFROM gaming_technology.game_sessions AS gs\nJOIN gaming_technology.servers AS s\n  ON gs.server_id = s.server_id\nGROUP BY\n  s.server_id,\n  s.server_name,\n  s.game_id;"}, {"role": "user", "content": "Only include servers where the total session duration is greater than 1 day (86400 seconds)."}, {"role": "assistant", "content": "SELECT\n  s.server_name,\n  s.game_id,\n  COUNT(gs.session_id) AS total_sessions,\n  SUM(gs.duration_seconds) AS total_duration_seconds\nFROM gaming_technology.game_sessions AS gs\nJOIN gaming_technology.servers AS s\n  ON gs.server_id = s.server_id\nGROUP BY\n  s.server_id,\n  s.server_name,\n  s.game_id\nHAVING\n  SUM(gs.duration_seconds) > 86400;"}, {"role": "user", "content": "Order the results by total session duration in descending order."}, {"role": "assistant", "content": "SELECT\n  s.server_name,\n  s.game_id,\n  COUNT(gs.session_id) AS total_sessions,\n  SUM(gs.duration_seconds) AS total_duration_seconds\nFROM gaming_technology.game_sessions AS gs\nJOIN gaming_technology.servers AS s\n  ON gs.server_id = s.server_id\nGROUP BY\n  s.server_id,\n  s.server_name,\n  s.game_id\nHAVING\n  SUM(gs.duration_seconds) > 86400\nORDER BY\n  total_duration_seconds 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.game_sessions ( session_id.uuid, player_id.uuid, game_id.uuid, server_id.uuid, start_time.timestamptz, end_time.timestamptz, duration_seconds.integer, score.integer, session_data.jsonb )\nCREATE TABLE gaming_technology.servers ( server_id.uuid, game_id.uuid, server_name.text, region.text, ip_address.text, port.integer, current_players.integer, max_players.integer, status.text, last_heartbeat.timestamptz )\n"}
{"conversations": [{"role": "user", "content": "For each player, show their player_id and the number of unique games they have played sessions on."}, {"role": "assistant", "content": "SELECT player_id, COUNT(DISTINCT game_id) AS unique_games\nFROM gaming_technology.game_sessions\nGROUP BY player_id;"}, {"role": "user", "content": "Also show the total number of sessions they have played."}, {"role": "assistant", "content": "SELECT player_id, COUNT(DISTINCT game_id) AS unique_games, COUNT(*) AS total_sessions\nFROM gaming_technology.game_sessions\nGROUP BY player_id;"}, {"role": "user", "content": "Only include players who have played on more than 2 unique games."}, {"role": "assistant", "content": "SELECT player_id, COUNT(DISTINCT game_id) AS unique_games, COUNT(*) AS total_sessions\nFROM gaming_technology.game_sessions\nGROUP BY player_id\nHAVING COUNT(DISTINCT game_id) > 2;"}, {"role": "user", "content": "For each result, include the player's username as well."}, {"role": "assistant", "content": "SELECT p.player_id, p.username, COUNT(DISTINCT gs.game_id) AS unique_games, COUNT(*) AS total_sessions\nFROM gaming_technology.players p\nJOIN gaming_technology.game_sessions gs ON p.player_id = gs.player_id\nGROUP BY p.player_id, p.username\nHAVING COUNT(DISTINCT gs.game_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 gaming_technology.players ( player_id.uuid, username.text, email.text, password_hash.text, registration_date.timestamptz, last_login.timestamptz, country_code.text, status.text, profile_data.jsonb )\nCREATE TABLE gaming_technology.game_sessions (\n    session_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game session\n    player_id uuid NOT NULL, -- FK linking to the players table\n    game_id uuid NOT NULL, -- FK linking to the games table\n    server_id uuid, -- FK linking to the servers table (nullable for single-player)\n    start_time timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the session began\n    end_time timestamp with time zone, -- when the session ended (null if ongoing)\n    duration_seconds integer, -- calculated duration of the session in seconds\n    score integer, -- player's score for the session, if applicable\n    session_data jsonb, -- flexible field for session-specific info (e.g., map played, character used)\n    PRIMARY KEY (session_id)\n    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),\n    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id),\n    -- FOREIGN KEY (server_id) REFERENCES gaming_technology.servers(server_id)\n)\nCREATE TABLE gaming_technology.servers ( server_id uuid 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, game_id uuid, name text, description text, icon_url text, points integer, hidden boolean )\nCREATE TABLE gaming_technology.player_achievements ( player_achievement_id.uuid, player_id.uuid, achievement_id.uuid, unlocked_at.timestamptz )\nCREATE TABLE gaming_technology.in_game_items ( item_id uuid NOT NULL DEFAULT gen_random_uuid(), game_id uuid NOT NULL, item_name character varying(150) NOT NULL, item_type character varying(50) NOT NULL, description text, rarity character varying(30), cost_currency character varying(10), cost_amount numeric(12, 2), attributes jsonb, PRIMARY KEY (item_id) )\n"}
{"conversations": [{"role": "user", "content": "Please list the full name and status of clients who have not provided a company name."}, {"role": "assistant", "content": "SELECT first_name, last_name, status\nFROM legal_services.clients\nWHERE company_name 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 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 )\n"}
{"conversations": [{"role": "user", "content": "List the name of each agency and the total number of service locations it operates in New York State."}, {"role": "assistant", "content": "SELECT a.agency_name, COUNT(sl.location_id) AS location_count\nFROM government_services.agencies a\nLEFT JOIN government_services.service_locations sl ON a.agency_id = sl.agency_id\nWHERE sl.state = 'NY'\nGROUP BY a.agency_name;"}, {"role": "user", "content": "Actually, only include those service locations that are accessible."}, {"role": "assistant", "content": "SELECT a.agency_name, COUNT(sl.location_id) AS location_count\nFROM government_services.agencies a\nLEFT JOIN government_services.service_locations sl ON a.agency_id = sl.agency_id\nWHERE sl.state = 'NY' AND sl.is_accessible = TRUE\nGROUP BY a.agency_name;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.agencies ( agency_id 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.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.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 service location, find its nearest accessible location by geographic distance."}, {"role": "assistant", "content": "SELECT sl.location_id,\n       sl.location_name,\n       nearest.location_id   AS nearest_location_id,\n       nearest.location_name AS nearest_location_name\nFROM government_services.service_locations sl\nJOIN LATERAL (\n  SELECT sl2.location_id,\n         sl2.location_name\n  FROM government_services.service_locations sl2\n  WHERE sl2.is_accessible = TRUE\n    AND sl2.location_id <> sl.location_id\n  ORDER BY ((sl.latitude - sl2.latitude)^2 + (sl.longitude - sl2.longitude)^2) ASC\n  LIMIT 1\n) AS nearest ON TRUE;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE government_services.service_locations ( location_id.text, agency_id.text, location_name.text, address.text, city.text, state.text, postal_code.text, latitude.numeric, longitude.numeric, operating_hours.text, contact_phone.text, is_accessible.boolean )\n"}
{"conversations": [{"role": "user", "content": "List each property along with the count of available rooms grouped by bed type."}, {"role": "assistant", "content": "SELECT rt.property_id, p.property_name, rt.bed_type, COUNT(r.room_id) AS available_count\nFROM hospitality_technology.rooms r\nJOIN hospitality_technology.room_types rt ON r.room_type_id = rt.room_type_id\nJOIN hospitality_technology.properties p ON rt.property_id = p.property_id\nWHERE r.status = 'Available'\nGROUP BY rt.property_id, p.property_name, rt.bed_type;"}], "system": "You are an SQL statement expert. Given the table structure described by the CREATE TABLE statement, write an SQL query that provides the solution to the user's question.\n##Table Structure\nCREATE TABLE 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.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.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 )\n"}
{"conversations": [{"role": "user", "content": "Show me all documents uploaded by lawyers from law firms located in 'New York'. Include the document name, upload timestamp, the first and last name of the uploading lawyer, and the firm name."}, {"role": "assistant", "content": "SELECT d.document_name, d.upload_timestamp, l.first_name AS lawyer_first_name, l.last_name AS lawyer_last_name, lf.firm_name FROM documents AS d JOIN lawyers AS l ON d.uploaded_by_lawyer_id = l.lawyer_id JOIN law_firms AS lf ON l.firm_id = lf.firm_id WHERE lf.address LIKE '%New York%';"}, {"role": "user", "content": "Okay, but only show documents where the document type is 'Contract'."}, {"role": "assistant", "content": "SELECT d.document_name, d.upload_timestamp, l.first_name AS lawyer_first_name, l.last_name AS lawyer_last_name, lf.firm_name FROM documents AS d JOIN lawyers AS l ON d.uploaded_by_lawyer_id = l.lawyer_id JOIN law_firms AS lf ON l.firm_id = lf.firm_id WHERE lf.address LIKE '%New York%' AND d.document_type = 'Contract';"}, {"role": "user", "content": "Also, sort the results by upload timestamp descending and include the document version."}, {"role": "assistant", "content": "SELECT d.document_name, d.upload_timestamp, d.version, l.first_name AS lawyer_first_name, l.last_name AS lawyer_last_name, lf.firm_name FROM documents AS d JOIN lawyers AS l ON d.uploaded_by_lawyer_id = l.lawyer_id JOIN law_firms AS lf ON l.firm_id = lf.firm_id WHERE lf.address LIKE '%New York%' AND d.document_type = 'Contract' ORDER BY d.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.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": "List the content and sent time for messages sent by user 'U101'."}, {"role": "assistant", "content": "SELECT content, sent_at FROM social_media.messages WHERE sender_user_id = 'U101';"}, {"role": "user", "content": "Could you also include the group name for those messages and only show messages sent in group chats?"}, {"role": "assistant", "content": "SELECT m.content, m.sent_at, c.name AS group_name FROM social_media.messages m JOIN social_media.conversations c ON m.conversation_id = c.conversation_id WHERE m.sender_user_id = 'U101' AND c.type = 'group';"}, {"role": "user", "content": "Now filter to include only messages sent in June 2024 and order them by sent time descending."}, {"role": "assistant", "content": "SELECT m.content, m.sent_at, c.name AS group_name FROM social_media.messages m JOIN social_media.conversations c ON m.conversation_id = c.conversation_id WHERE m.sender_user_id = 'U101' AND c.type = 'group' AND m.sent_at >= '2024-06-01' AND m.sent_at < '2024-07-01' ORDER BY m.sent_at DESC;"}, {"role": "user", "content": "Also limit the results to the top 15."}, {"role": "assistant", "content": "SELECT m.content, m.sent_at, c.name AS group_name FROM social_media.messages m JOIN social_media.conversations c ON m.conversation_id = c.conversation_id WHERE m.sender_user_id = 'U101' AND c.type = 'group' AND m.sent_at >= '2024-06-01' AND m.sent_at < '2024-07-01' ORDER BY m.sent_at DESC LIMIT 15;"}], "system": "You are an SQL statement expert. Given the table structure 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.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)\n"}