System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE project_fundraising_record ( id.text, project_id.text, project_name.text, rounds_name.text, investment_value.numeric, investment_date.text, introduction.text, valuation.numeric )

[User] List all fundraising rounds where the average investment amount exceeded $10M, and show how many projects participated in each round.

[Assistant] SELECT rounds_name, COUNT(DISTINCT project_id) AS project_count, AVG(investment_value) AS avg_investment FROM project_fundraising_record GROUP BY rounds_name HAVING AVG(investment_value) > 10000000;

[User] Now, only consider rounds with at least 3 projects.

[Assistant] SELECT rounds_name, COUNT(DISTINCT project_id) AS project_count, AVG(investment_value) AS avg_investment FROM project_fundraising_record GROUP BY rounds_name HAVING AVG(investment_value) > 10000000 AND COUNT(DISTINCT project_id) >= 3;

[User] Add the total raised amount in each selected round.

[Assistant] SELECT rounds_name, COUNT(DISTINCT project_id) AS project_count, AVG(investment_value) AS avg_investment, SUM(investment_value) AS total_raised FROM project_fundraising_record GROUP BY rounds_name HAVING AVG(investment_value) > 10000000 AND COUNT(DISTINCT project_id) >= 3;

[User] Show the result ordered by total_raised in descending order, and only the top 2 rounds.

[Assistant] SELECT rounds_name, project_count, avg_investment, total_raised FROM (SELECT rounds_name, COUNT(DISTINCT project_id) AS project_count, AVG(investment_value) AS avg_investment, SUM(investment_value) AS total_raised FROM project_fundraising_record GROUP BY rounds_name HAVING AVG(investment_value) > 10000000 AND COUNT(DISTINCT project_id) >= 3) t ORDER BY total_raised DESC LIMIT 2;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE social_media.users ( user_id text, username text, email text, password_hash text, full_name text, profile_picture_url text, bio text, location text, created_at timestamp, updated_at timestamp, is_verified boolean )
CREATE TABLE social_media.posts ( post_id text PRIMARY KEY, user_id text, content text, media_url text, media_type text, created_at timestamp, updated_at timestamp, visibility text, location_lat numeric, location_lon numeric )
CREATE TABLE social_media.comments ( comment_id.text, post_id.text, user_id.text, parent_comment_id.text, content.text, created_at.timestamp, updated_at.timestamp )
CREATE TABLE social_media.likes ( like_id text PRIMARY KEY, user_id text, post_id text, comment_id text, created_at timestamp )
CREATE TABLE social_media.follows ( follow_id character varying(64) NOT NULL, follower_user_id character varying(64) NOT NULL, following_user_id character varying(64) NOT NULL, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (follow_id), CONSTRAINT unique_follow UNIQUE (follower_user_id, following_user_id) )
CREATE TABLE social_media.post_hashtags ( post_hashtag_id text, post_id text, hashtag_id text )
CREATE TABLE social_media.conversations ( conversation_id.text, created_at.timestamp, last_message_at.timestamp, is_group_chat.boolean, group_name.text )
CREATE TABLE social_media.conversation_participants ( participant_id.text, conversation_id.text, user_id.text, joined_at.timestamp, last_read_at.timestamp )
CREATE 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) )
CREATE TABLE social_media.user_settings ( setting_id text PRIMARY KEY, user_id text, theme text, email_notifications_enabled bool, push_notifications_enabled bool, private_profile bool, updated_at timestamp )

[User] List all hashtags and for each, show how many different users have created posts using that hashtag.

[Assistant]
SELECT ph.hashtag_id, COUNT(DISTINCT p.user_id) AS unique_user_count
FROM social_media.post_hashtags ph
JOIN social_media.posts p ON ph.post_id = p.post_id
GROUP BY ph.hashtag_id;

[User] Only include hashtags used by at least 3 users.

[Assistant]
SELECT ph.hashtag_id, COUNT(DISTINCT p.user_id) AS unique_user_count
FROM social_media.post_hashtags ph
JOIN social_media.posts p ON ph.post_id = p.post_id
GROUP BY ph.hashtag_id
HAVING COUNT(DISTINCT p.user_id) >= 3;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE 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) )
CREATE 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) )
CREATE TABLE transportation.maintenance_logs ( log_id character varying(64) NOT NULL, vehicle_id character varying(64) NOT NULL, service_date date NOT NULL, odometer_reading integer, service_type character varying(128) NOT NULL, description text NOT NULL, cost numeric(10, 2), mechanic_name character varying(128), next_service_due_date date, PRIMARY KEY (log_id) )
CREATE TABLE transportation.passengers ( passenger_id character varying(64) NOT NULL, first_name character varying(128) NOT NULL, last_name character varying(128) NOT NULL, email character varying(128) UNIQUE, phone_number character varying(32) UNIQUE, date_of_birth date, loyalty_program_id character varying(64), created_at timestamp with time zone NOT NULL, PRIMARY KEY (passenger_id) )
CREATE 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) )

[User] What is the average maintenance cost per vehicle?

[Assistant]
SELECT vehicle_id, AVG(cost) AS avg_cost
FROM transportation.maintenance_logs
GROUP BY vehicle_id;

[User] Only include vehicles with average maintenance cost greater than 300.

[Assistant]
SELECT vehicle_id, AVG(cost) AS avg_cost
FROM transportation.maintenance_logs
GROUP BY vehicle_id
HAVING AVG(cost) > 300;

[User] Also display the most recent service_date for each vehicle.

[Assistant]
SELECT vehicle_id, AVG(cost) AS avg_cost, MAX(service_date) AS last_service_date
FROM transportation.maintenance_logs
GROUP BY vehicle_id
HAVING AVG(cost) > 300;

[User] Finally, restrict to vehicles that have at least 5 maintenance records.

[Assistant]
SELECT vehicle_id, AVG(cost) AS avg_cost, MAX(service_date) AS last_service_date, COUNT(*) AS service_count
FROM transportation.maintenance_logs
GROUP BY vehicle_id
HAVING AVG(cost) > 300 AND COUNT(*) >= 5;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE government_services.agencies ( agency_id character varying(64) NOT NULL, agency_name character varying(255) NOT NULL, jurisdiction_level character varying(50) NOT NULL, primary_contact_email character varying(128), main_phone_number character varying(32), website_url character varying(255), established_date date, parent_agency_id character varying(64), PRIMARY KEY (agency_id) )
CREATE TABLE government_services.appointments ( appointment_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, employee_id character varying(64), location_id character varying(64), service_id character varying(64), scheduled_start_time timestamp NOT NULL, scheduled_end_time timestamp, purpose text NOT NULL, status character varying(30) NOT NULL, booking_method character varying(50), created_at timestamp NOT NULL, notes text, PRIMARY KEY (appointment_id) )

[User] List the name of each agency and the number of appointments associated with services from that agency.

[Assistant] SELECT T1.agency_name, COUNT(T2.appointment_id) FROM agencies AS T1 JOIN appointments AS T2 ON T1.agency_id = T2.agency_id GROUP BY T1.agency_name;


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

[User] Show me all payments along with the currency code and payment method for each payment, and include the amount and status. Group the results by payment method and currency code, and order by total payment amount descending.

[Assistant]
SELECT payment_method, currency_code, SUM(amount) AS total_payment_amount, COUNT(*) AS payment_count
FROM hospitality_technology.payments
GROUP BY payment_method, currency_code
ORDER BY total_payment_amount DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE social_media.posts ( post_id text PRIMARY KEY, user_id text, content text, media_url text, media_type text, created_at timestamp, updated_at timestamp, visibility text, location_lat numeric, location_lon numeric )

[User] How many posts are currently marked as 'private' visibility?

[Assistant] SELECT COUNT(*) FROM social_media.posts WHERE visibility = 'private'


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.prescriptions (
    prescription_id character varying(64) NOT NULL, -- unique identifier for the prescription
    record_id character varying(64) NOT NULL, -- FK linking to the medical record where it was prescribed
    patient_id character varying(64) NOT NULL, -- FK to patients table
    doctor_id character varying(64) NOT NULL, -- FK to prescribing doctor
    medication_id character varying(64) NOT NULL, -- FK to medications table
    dosage character varying(100) NOT NULL, -- e.g., '100mg', '1 tablet'
    frequency character varying(100) NOT NULL, -- e.g., 'Once daily', 'Twice a day with meals'
    route character varying(50), -- e.g., 'Oral', 'Topical', 'Intravenous'
    start_date date NOT NULL, -- date prescription begins
    end_date date, -- date prescription ends (if applicable)
    quantity_dispensed numeric(10,2), -- amount dispensed (e.g., number of tablets)
    refills_allowed integer NOT NULL DEFAULT 0, -- number of allowed refills
    prescription_date timestamp with time zone NOT NULL DEFAULT current_timestamp,
    PRIMARY KEY (prescription_id)
)

[User] Which doctors have issued prescriptions with a route of 'Oral'? Please show doctor_id and the number of such prescriptions they have written.

[Assistant]
SELECT doctor_id, COUNT(*) AS oral_prescription_count
FROM healthcare.prescriptions
WHERE route = 'Oral'
GROUP BY doctor_id;

[User] Now, only include doctors who have written more than 10 oral prescriptions and sort the list by oral_prescription_count descending.

[Assistant]
SELECT doctor_id, COUNT(*) AS oral_prescription_count
FROM healthcare.prescriptions
WHERE route = 'Oral'
GROUP BY doctor_id
HAVING COUNT(*) > 10
ORDER BY oral_prescription_count DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE insurance.policies (
    policy_id character varying(64) NOT NULL, -- unique identifier for the policy
    customer_id character varying(64) NOT NULL, -- identifier for the policyholder (FK to customers)
    product_id character varying(64) NOT NULL, -- identifier for the insurance product (FK to insurance_products)
    agent_id character varying(64), -- identifier for the agent who sold the policy (FK to agents)
    policy_number character varying(100) NOT NULL UNIQUE, -- customer-facing policy number
    start_date date NOT NULL, -- date the policy coverage begins
    end_date date NOT NULL, -- date the policy coverage ends
    premium_amount numeric(12, 2) NOT NULL, -- total premium for the policy term
    coverage_limit numeric(15, 2) NOT NULL, -- maximum amount covered
    deductible numeric(10, 2) NOT NULL, -- amount customer pays before coverage kicks in
    status character varying(30) NOT NULL, -- e.g., Active, Expired, Cancelled, Pending
    issued_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the policy was issued
    cancellation_date date,
    cancellation_reason text,
    PRIMARY KEY (policy_id)
)
CREATE TABLE insurance.insurance_products (
    product_id character varying(64) NOT NULL, -- unique identifier for the insurance product
    product_name character varying(150) NOT NULL, -- name of the insurance product (e.g., 'Comprehensive Auto Insurance')
    product_type character varying(50) NOT NULL, -- category like 'Auto', 'Home', 'Life', 'Health', 'Travel'
    description text, -- detailed description of the product
    base_premium numeric(10, 2) NOT NULL, -- starting premium before adjustments
    coverage_details text, -- details about what is covered (could be JSON or structured text)
    underwriting_rules text, -- rules used for assessing risk and eligibility
    is_active boolean NOT NULL DEFAULT true, -- whether the product is currently offered
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at timestamp,
    PRIMARY KEY (product_id)
)
CREATE TABLE insurance.premium_payments (
    payment_id character varying(64) NOT NULL, -- unique identifier for the payment
    policy_id character varying(64) NOT NULL, -- identifier of the policy the payment is for (FK to policies)
    customer_id character varying(64) NOT NULL, -- identifier of the customer making the payment (FK to customers)
    payment_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the payment was received
    amount_paid numeric(12, 2) NOT NULL, -- amount of the payment
    payment_method character varying(50), -- e.g., Credit Card, Bank Transfer, Check
    transaction_reference character varying(128) UNIQUE, -- reference from payment processor
    due_date date, -- due date for this payment installment
    payment_period_start date, -- start date of the period this payment covers
    payment_period_end date, -- end date of the period this payment covers
    status character varying(30) NOT NULL DEFAULT 'Completed', -- e.g., Completed, Pending, Failed, Refunded
    PRIMARY KEY (payment_id)
)

[User] List all active policies, including their policy number, start date, end date, premium amount, and the name of the insurance product.

[Assistant] SELECT T1.policy_number, T1.start_date, T1.end_date, T1.premium_amount, T2.product_name FROM insurance.policies AS T1 JOIN insurance.insurance_products AS T2 ON T1.product_id = T2.product_id WHERE T1.status = 'Active';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.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) )
CREATE TABLE legal_services.cases ( case_id character varying(64) NOT NULL, case_number character varying(100) UNIQUE, case_name text NOT NULL, client_id character varying(64) NOT NULL, lead_lawyer_id character varying(64) NOT NULL, case_type character varying(100) NOT NULL, status character varying(50) NOT NULL, date_opened timestamp NOT NULL, date_closed timestamp, description text, court_jurisdiction character varying(128), PRIMARY KEY (case_id) )

[User] Show me all case numbers along with the firm_name of the law firm where the lead lawyer is the managing partner.

[Assistant]
SELECT c.case_number, l.firm_name
FROM legal_services.cases c
JOIN legal_services.law_firms l
  ON c.lead_lawyer_id = l.managing_partner_id;

[User] Now only include cases with status 'Closed' and show the date_closed as well.

[Assistant]
SELECT c.case_number, l.firm_name, c.date_closed
FROM legal_services.cases c
JOIN legal_services.law_firms l
  ON c.lead_lawyer_id = l.managing_partner_id
WHERE c.status = 'Closed';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE web3.contracts (
    contract_id character varying(64) NOT NULL,  -- unique identifier for the contract
    address character varying(128) NOT NULL, -- address of the deployed contract
    abi text NOT NULL, -- application binary interface of the contract
    bytecode text NOT NULL, -- bytecode of the contract
    deployer_address character varying(128) NOT NULL, -- address of the deployer
    deployed_at timestamp NOT NULL, -- time when the contract was deployed
    network_id character varying(64) NOT NULL, -- identifier of the network where the contract is deployed
    status character varying(32) NOT NULL, -- status of the contract (e.g., active, deprecated)
    PRIMARY KEY (contract_id)
)

[User] For each distinct deployer address, how many contracts have they deployed and what is the most recent deployment time? Please show deployer_address, contract_count, and latest_deployed_at.

[Assistant]
SELECT deployer_address, COUNT(*) AS contract_count, MAX(deployed_at) AS latest_deployed_at
FROM web3.contracts
GROUP BY deployer_address;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
Node Label ':AircraftModel'. Properties: { model_id: String (Constraint: UNIQUE), model_name: String, manufacturer: String, passenger_capacity: Integer, max_range_km: Integer, engine_type: String, wingspan_m: Float, status: String, first_flight_date: Date }. Index on model_id.
Node Label ':Component'. Properties: { component_id: String (Constraint: UNIQUE), part_number: String (Constraint: UNIQUE), component_name: String, description: String, weight_kg: Float, cost_usd: Float, criticality_level: String }. Relationships: (:Component)-[:MADE_OF]->(:Material {material_id}), (:Component)-[:SUPPLIED_BY]->(:Supplier {supplier_id}). Index on component_id, part_number.
Node Label ':Material'. Properties: { material_id: String (Constraint: UNIQUE), material_name: String, specification: String, description: String, density_kg_m3: Float, tensile_strength_mpa: Integer }. Index on material_id.
Node Label ':AssemblyLine'. Properties: { line_id: String (Constraint: UNIQUE), line_name: String, location_building: String, location_area: String, capacity_units_per_month: Integer, status: String }. Relationship: (:AssemblyLine)-[:BUILDS_MODEL]->(:AircraftModel {model_id}). Index on line_id.
Node Label ':AssemblyStep'. Properties: { step_id: String (Constraint: UNIQUE), step_number: Integer, step_name: String, description: String, standard_duration_hours: Float, required_skill_level: String, workstation: String }. Relationship: (:AssemblyLine {line_id})-[:HAS_STEP {sequence: <step_number>}]->(:AssemblyStep). Index on step_id.
Node Label ':AircraftBuild'. Properties: { build_id: String (Constraint: UNIQUE), serial_number: String (Constraint: UNIQUE), build_start_date: Datetime, estimated_completion_date: Date, actual_completion_date: Datetime, current_status: String, customer_order_id: String }. Relationships: (:AircraftBuild)-[:IS_MODEL]->(:AircraftModel {model_id}), (:AircraftBuild)-[:ASSEMBLED_ON]->(:AssemblyLine {line_id}). Index on build_id, serial_number, current_status.
Node Label ':Inspection'. Properties: { inspection_id: String (Constraint: UNIQUE), inspection_type: String, inspection_timestamp: Datetime, result: String, remarks: String }. Relationships: (:AircraftBuild {build_id})-[:UNDERWENT]->(:Inspection), (:Inspection)-[:PERFORMED_BY]->(:Employee {employee_id}), (:Inspection)-[:INSPECTED_COMPONENT]->(:Component {component_id}) (optional), (:Inspection)-[:FOLLOWED_STEP]->(:AssemblyStep {step_id}) (optional). Index on inspection_id.

[User] 我想查询某个飞机构建的所有检查记录，包括检查类型、检查结果、检查时间以及被检查的组件名称。

[Assistant]
MATCH (ab:AircraftBuild)-[:UNDERWENT]->(i:Inspection)-[:INSPECTED_COMPONENT]->(c:Component)
WHERE ab.build_id = 'specific_build_id'
RETURN i.inspection_type, i.result, i.inspection_timestamp, c.component_name

[User] 如果我想只显示检查结果为'Fail'的记录，应该怎么修改？

[Assistant]
MATCH (ab:AircraftBuild)-[:UNDERWENT]->(i:Inspection)-[:INSPECTED_COMPONENT]->(c:Component)
WHERE ab.build_id = 'specific_build_id' AND i.result = 'Fail'
RETURN i.inspection_type, i.result, i.inspection_timestamp, c.component_name

[User] 能否再加上一个条件，只显示检查时间在2023年6月1日之后的记录？

[Assistant]
MATCH (ab:AircraftBuild)-[:UNDERWENT]->(i:Inspection)-[:INSPECTED_COMPONENT]->(c:Component)
WHERE ab.build_id = 'specific_build_id' AND i.result = 'Fail' AND i.inspection_timestamp >= datetime('2023-06-01')
RETURN i.inspection_type, i.result, i.inspection_timestamp, c.component_name

[User] 请再加上检查备注字段，并按检查时间从新到旧排序。

[Assistant]
MATCH (ab:AircraftBuild)-[:UNDERWENT]->(i:Inspection)-[:INSPECTED_COMPONENT]->(c:Component)
WHERE ab.build_id = 'specific_build_id' AND i.result = 'Fail' AND i.inspection_timestamp >= datetime('2023-06-01')
RETURN i.inspection_type, i.result, i.inspection_timestamp, c.component_name, i.remarks
ORDER BY i.inspection_timestamp DESC


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.users ( user_id character varying(64) NOT NULL, username character varying(128) NOT NULL, email character varying(128) NOT NULL, password_hash text NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (user_id) )
CREATE TABLE trading_platform.wallets ( wallet_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, address character varying(128) NOT NULL, private_key text NOT NULL, created_at timestamp NOT NULL, PRIMARY KEY (wallet_id) )
CREATE TABLE trading_platform.orders ( order_id text PRIMARY KEY, user_id text, wallet_id text, asset_id text, order_type text, quantity numeric, price numeric, status text, created_at timestamp )
CREATE TABLE trading_platform.trades (
    trade_id character varying(64) NOT NULL,  -- unique identifier for the trade
    order_id character varying(64) NOT NULL, -- identifier of the order that led to the trade
    buyer_id character varying(64) NOT NULL, -- identifier of the buyer
    seller_id character varying(64) NOT NULL, -- identifier of the seller
    asset_id character varying(64) NOT NULL, -- identifier of the asset being traded
    quantity numeric(38,14) NOT NULL, -- quantity of the asset in the trade
    price numeric(38,14) NOT NULL, -- price per unit of the asset
    traded_at timestamp NOT NULL, -- time when the trade was executed
    PRIMARY KEY (trade_id)
)
CREATE TABLE trading_platform.assets ( asset_id text PRIMARY KEY, name text, symbol text, type text )
CREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )
CREATE TABLE trading_platform.dapps ( dapp_id.text, name.text, description.text, url.text )
CREATE TABLE trading_platform.metadata (
    metadata_id character varying(64) NOT NULL,  -- unique identifier for the metadata
    asset_id character varying(64) NOT NULL, -- identifier of the asset the metadata is associated with
    key character varying(128) NOT NULL, -- key of the metadata
    value text NOT NULL, -- value of the metadata
    PRIMARY KEY (metadata_id)
)
CREATE TABLE trading_platform.kyc_audit (
    kyc_audit_id character varying(64) NOT NULL,  -- unique identifier for the KYC audit
    user_id character varying(64) NOT NULL, -- identifier of the user being audited
    status character varying(32) NOT NULL, -- status of the KYC audit (e.g., pending, approved, rejected)
    reviewed_at timestamp NOT NULL, -- time when the KYC audit was reviewed
    PRIMARY KEY (kyc_audit_id)
)

[User] Show me a list of all users who have participated in any trade (either as a buyer or a seller), including their username and the total number of trades they were involved in.

[Assistant] SELECT T1.username , count(T2.trade_id) FROM trading_platform.users AS T1 JOIN (SELECT buyer_id, trade_id FROM trading_platform.trades UNION ALL SELECT seller_id, trade_id FROM trading_platform.trades) AS T2 ON T1.user_id  =  T2.buyer_id GROUP BY T1.username

[User] From that list, now only show users who were involved in at least one trade *as a buyer*, and include their email address as well.

[Assistant] SELECT T1.username , T1.email , count(T2.trade_id) FROM trading_platform.users AS T1 JOIN trading_platform.trades AS T2 ON T1.user_id  =  T2.buyer_id GROUP BY T1.username , T1.email HAVING count(T2.trade_id)  >=  1


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE insurance.customers ( customer_id text PRIMARY KEY, first_name text, last_name text, date_of_birth date, ssn_hash text, address_line1 text, address_line2 text, city text, state text, zip_code text, country text, phone_number text, email text, created_at timestamp, updated_at timestamp, status text )
CREATE 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 )
CREATE TABLE insurance.claims ( claim_id text PRIMARY KEY, policy_id text, customer_id text, incident_date timestamp, reported_date timestamp, description text, estimated_loss numeric, status text, settlement_amount numeric, settlement_date date, claim_handler_id text, police_report_number text )
CREATE TABLE insurance.insurance_products ( product_id text PRIMARY KEY, product_name text, product_type text, description text, base_premium numeric, coverage_details text, underwriting_rules text, is_active boolean, created_at timestamp, updated_at timestamp )
CREATE TABLE insurance.agents ( agent_id text PRIMARY KEY, first_name text, last_name text, agency_name text, license_number text, license_state text, contact_email text, contact_phone text, hire_date date, termination_date date, status text, commission_rate numeric, manager_id text )
CREATE TABLE insurance.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 )

[User] Show me the first and last names of customers who have purchased a policy for an insurance product of type 'travel', along with the policy number and product name.

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

[User] Add the premium_amount of the policy and the product's base_premium to the result, and only include policies with status 'active'.

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

[User] Can you also show only the records where the premium_amount of the policy is greater than the product's base_premium?

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


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.wallets (
    wallet_id character varying(64) NOT NULL,  -- unique identifier for the wallet
    user_id character varying(64) NOT NULL, -- identifier of the user owning the wallet
    address character varying(128) NOT NULL, -- address of the wallet
    private_key text NOT NULL, -- private key of the wallet
    created_at timestamp NOT NULL, -- time when the wallet was created
    PRIMARY KEY (wallet_id)
)
CREATE TABLE trading_platform.orders (
    order_id character varying(64) NOT NULL,  -- unique identifier for the order
    user_id character varying(64) NOT NULL, -- identifier of the user placing the order
    wallet_id character varying(64) NOT NULL, -- identifier of the wallet used for the order
    asset_id character varying(64) NOT NULL, -- identifier of the asset being traded
    order_type character varying(32) NOT NULL, -- type of the order (e.g., buy, sell)
    quantity numeric(38,14) NOT NULL, -- quantity of the asset in the order
    price numeric(38,14) NOT NULL, -- price per unit of the asset
    status character varying(32) NOT NULL, -- status of the order (e.g., open, filled, canceled)
    created_at timestamp NOT NULL, -- time when the order was created
    PRIMARY KEY (order_id)
)
CREATE TABLE trading_platform.assets (
    asset_id character varying(64) NOT NULL,  -- unique identifier for the asset
    name character varying(128) NOT NULL, -- name of the asset
    symbol character varying(32) NOT NULL, -- symbol of the asset
    type character varying(32) NOT NULL, -- type of the asset (e.g., cryptocurrency, stock)
    PRIMARY KEY (asset_id)
)
CREATE TABLE trading_platform.utxos (
    utxo_id character varying(64) NOT NULL,  -- unique identifier for the UTXO
    transaction_id character varying(64) NOT NULL, -- identifier of the transaction that created the UTXO
    output_index integer NOT NULL, -- index of the output in the transaction
    address character varying(128) NOT NULL, -- address that can spend the UTXO
    amount numeric(38,14) NOT NULL, -- amount of the asset in the UTXO
    spent boolean NOT NULL, -- whether the UTXO has been spent
    PRIMARY KEY (utxo_id)
)
CREATE TABLE trading_platform.dapps (
    dapp_id character varying(64) NOT NULL,  -- unique identifier for the DApp
    name character varying(128) NOT NULL, -- name of the DApp
    description text NOT NULL, -- description of the DApp
    url character varying(256) NOT NULL, -- URL of the DApp
    PRIMARY KEY (dapp_id)
)
CREATE TABLE trading_platform.peers (
    peer_id character varying(64) NOT NULL,  -- unique identifier for the peer
    ip_address character varying(15) NOT NULL, -- IP address of the peer
    port integer NOT NULL, -- port number of the peer
    last_seen timestamp NOT NULL, -- last time the peer was active
    PRIMARY KEY (peer_id)
)
CREATE TABLE trading_platform.metadata (
    metadata_id character varying(64) NOT NULL,  -- unique identifier for the metadata
    asset_id character varying(64) NOT NULL, -- identifier of the asset the metadata is associated with
    key character varying(128) NOT NULL, -- key of the metadata
    value text NOT NULL, -- value of the metadata
    PRIMARY KEY (metadata_id)
)
CREATE TABLE trading_platform.kyc_audit (
    kyc_audit_id character varying(64) NOT NULL,  -- unique identifier for the KYC audit
    user_id character varying(64) NOT NULL, -- identifier of the user being audited
    status character varying(32) NOT NULL, -- status of the KYC audit (e.g., pending, approved, rejected)
    reviewed_at timestamp NOT NULL, -- time when the KYC audit was reviewed
    PRIMARY KEY (kyc_audit_id)
)
CREATE TABLE trading_platform.notifications (
    notification_id character varying(64) NOT NULL,  -- unique identifier for the notification
    user_id character varying(64) NOT NULL, -- identifier of the user receiving the notification
    message text NOT NULL, -- message of the notification
    sent_at timestamp NOT NULL, -- time when the notification was sent
    read_at timestamp, -- time when the notification was read
    PRIMARY KEY (notification_id)
)

[User] List each asset's name and symbol along with the total number of open orders for that asset.

[Assistant]
SELECT a.name,
       a.symbol,
       COUNT(o.order_id) AS open_order_count
FROM trading_platform.assets a
LEFT JOIN trading_platform.orders o
  ON a.asset_id = o.asset_id
  AND o.status = 'open'
GROUP BY a.name, a.symbol;

[User] Now restrict the results to only assets with more than 5 open orders.

[Assistant]
SELECT a.name,
       a.symbol,
       COUNT(o.order_id) AS open_order_count
FROM trading_platform.assets a
LEFT JOIN trading_platform.orders o
  ON a.asset_id = o.asset_id
  AND o.status = 'open'
GROUP BY a.name, a.symbol
HAVING COUNT(o.order_id) > 5;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE 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 )
CREATE TABLE gaming_technology.developers (
    developer_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the developer studio
    name character varying(150) NOT NULL UNIQUE, -- name of the development studio
    country character varying(100), -- country where the studio is based
    founded_year integer, -- year the studio was founded
    website character varying(255), -- developer's official website
    created_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (developer_id)
)
CREATE TABLE gaming_technology.player_achievements ( player_achievement_id.uuid, player_id.uuid, achievement_id.uuid, unlocked_at.timestamptz )

[User] Can you find all players who registered in 2023 and unlocked at least one achievement?

[Assistant]
SELECT DISTINCT p.player_id, p.username
FROM gaming_technology.players p
JOIN gaming_technology.player_achievements pa ON p.player_id = pa.player_id
WHERE EXTRACT(YEAR FROM p.registration_date) = 2023;

[User] Please also show how many achievements each player unlocked.

[Assistant]
SELECT p.player_id, p.username, COUNT(pa.achievement_id) AS achievements_unlocked
FROM gaming_technology.players p
JOIN gaming_technology.player_achievements pa ON p.player_id = pa.player_id
WHERE EXTRACT(YEAR FROM p.registration_date) = 2023
GROUP BY p.player_id, p.username;

[User] Now, can you add each player’s country_code and sort the results by achievements_unlocked in descending order?

[Assistant]
SELECT p.player_id, p.username, p.country_code, COUNT(pa.achievement_id) AS achievements_unlocked
FROM gaming_technology.players p
JOIN gaming_technology.player_achievements pa ON p.player_id = pa.player_id
WHERE EXTRACT(YEAR FROM p.registration_date) = 2023
GROUP BY p.player_id, p.username, p.country_code
ORDER BY achievements_unlocked DESC;


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

[User] I need to know how many distinct wallets hold each ERC20 token. Please show the token contract_address, symbol, and holder_count, sorted by holder_count descending.

[Assistant]
SELECT eb.contract_address, tm.symbol, COUNT(DISTINCT eb.wallet_address) AS holder_count
FROM erc20_balances eb
JOIN token_metas tm ON eb.contract_address = tm.contract_address
WHERE tm.is_erc20 = 1
GROUP BY eb.contract_address, tm.symbol
ORDER BY holder_count DESC;

[User] Now, only include tokens where holder_count > 1000 and limit to top 10.

[Assistant]
SELECT eb.contract_address, tm.symbol, COUNT(DISTINCT eb.wallet_address) AS holder_count
FROM erc20_balances eb
JOIN token_metas tm ON eb.contract_address = tm.contract_address
WHERE tm.is_erc20 = 1
GROUP BY eb.contract_address, tm.symbol
HAVING COUNT(DISTINCT eb.wallet_address) > 1000
ORDER BY holder_count DESC
LIMIT 10;

[User] Add the token name from metadata to the result.

[Assistant]
SELECT eb.contract_address, tm.symbol, tm.name, COUNT(DISTINCT eb.wallet_address) AS holder_count
FROM erc20_balances eb
JOIN token_metas tm ON eb.contract_address = tm.contract_address
WHERE tm.is_erc20 = 1
GROUP BY eb.contract_address, tm.symbol, tm.name
HAVING COUNT(DISTINCT eb.wallet_address) > 1000
ORDER BY holder_count DESC
LIMIT 10;

[User] Also include the latest USD price for each token by joining token_prices_latest and only show tokens with price > 1.0.

[Assistant]
SELECT eb.contract_address, tm.symbol, tm.name, tpl.price AS latest_price, COUNT(DISTINCT eb.wallet_address) AS holder_count
FROM erc20_balances eb
JOIN token_metas tm ON eb.contract_address = tm.contract_address
JOIN token_prices_latest tpl ON eb.contract_address = tpl.address AND tpl.blockchain = 'Ethereum'
WHERE tm.is_erc20 = 1
  AND tpl.price > 1.0
GROUP BY eb.contract_address, tm.symbol, tm.name, tpl.price
HAVING COUNT(DISTINCT eb.wallet_address) > 1000
ORDER BY holder_count DESC
LIMIT 10;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE 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 )
CREATE TABLE gaming_technology.servers ( server_id.uuid, game_id.uuid, server_name.text, region.text, ip_address.text, port.integer, current_players.integer, max_players.integer, status.text, last_heartbeat.timestamptz )

[User] How many servers are in each region, and what's the average number of current players for those servers?

[Assistant]
SELECT
  region,
  COUNT(server_id) AS server_count,
  AVG(current_players) AS average_current_players
FROM gaming_technology.servers
GROUP BY
  region;

[User] Only include regions with more than 5 servers.

[Assistant]
SELECT
  region,
  COUNT(server_id) AS server_count,
  AVG(current_players) AS average_current_players
FROM gaming_technology.servers
GROUP BY
  region
HAVING
  COUNT(server_id) > 5;

[User] Also, include the total maximum players capacity for each of these regions.

[Assistant]
SELECT
  region,
  COUNT(server_id) AS server_count,
  AVG(current_players) AS average_current_players,
  SUM(max_players) AS total_max_players
FROM gaming_technology.servers
GROUP BY
  region
HAVING
  COUNT(server_id) > 5;

[User] Order the results by the average current players in descending order.

[Assistant]
SELECT
  region,
  COUNT(server_id) AS server_count,
  AVG(current_players) AS average_current_players,
  SUM(max_players) AS total_max_players
FROM gaming_technology.servers
GROUP BY
  region
HAVING
  COUNT(server_id) > 5
ORDER BY
  average_current_players DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE gaming_technology.players ( player_id.uuid, username.text, email.text, password_hash.text, registration_date.timestamptz, last_login.timestamptz, country_code.text, status.text, profile_data.jsonb )
CREATE TABLE gaming_technology.game_sessions (
    session_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game session
    player_id uuid NOT NULL, -- FK linking to the players table
    game_id uuid NOT NULL, -- FK linking to the games table
    server_id uuid, -- FK linking to the servers table (nullable for single-player)
    start_time timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the session began
    end_time timestamp with time zone, -- when the session ended (null if ongoing)
    duration_seconds integer, -- calculated duration of the session in seconds
    score integer, -- player's score for the session, if applicable
    session_data jsonb, -- flexible field for session-specific info (e.g., map played, character used)
    PRIMARY KEY (session_id)
    -- FOREIGN KEY (player_id) REFERENCES gaming_technology.players(player_id),
    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id),
    -- FOREIGN KEY (server_id) REFERENCES gaming_technology.servers(server_id)
)
CREATE TABLE gaming_technology.servers ( server_id uuid NOT NULL DEFAULT gen_random_uuid(), 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) )
CREATE TABLE gaming_technology.achievements ( achievement_id uuid, game_id uuid, name text, description text, icon_url text, points integer, hidden boolean )
CREATE TABLE gaming_technology.player_achievements ( player_achievement_id.uuid, player_id.uuid, achievement_id.uuid, unlocked_at.timestamptz )
CREATE TABLE gaming_technology.in_game_items ( item_id uuid 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) )

[User] For each game, show the game ID, title, and the total number of players who have unlocked at least one achievement in that game.

[Assistant]
SELECT g.game_id, g.title, COUNT(DISTINCT pa.player_id) AS total_players
FROM gaming_technology.achievements a
JOIN gaming_technology.player_achievements pa ON a.achievement_id = pa.achievement_id
JOIN gaming_technology.games g ON a.game_id = g.game_id
GROUP BY g.game_id, g.title;

[User] Can you also include the number of achievements available for each game in the output?

[Assistant]
SELECT g.game_id, g.title, COUNT(DISTINCT pa.player_id) AS total_players, COUNT(DISTINCT a.achievement_id) AS achievements_count
FROM gaming_technology.achievements a
JOIN gaming_technology.player_achievements pa ON a.achievement_id = pa.achievement_id
JOIN gaming_technology.games g ON a.game_id = g.game_id
GROUP BY g.game_id, g.title;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.insurance_plans ( plan_id text PRIMARY KEY, plan_name text, insurance_provider text, plan_type text, contact_phone text, website text )

[User] Show me all pairs of plans offered by the same insurance provider but of different plan types, including the provider name, first plan ID and type, and second plan ID and type.

[Assistant]
SELECT a.insurance_provider,
       a.plan_id AS plan_id_1,
       a.plan_type AS type_1,
       b.plan_id AS plan_id_2,
       b.plan_type AS type_2
FROM healthcare.insurance_plans a
JOIN healthcare.insurance_plans b
  ON a.insurance_provider = b.insurance_provider
 AND a.plan_type <> b.plan_type
 AND a.plan_id < b.plan_id;

[User] Can you restrict this to only those providers that offer at least three distinct plan types?

[Assistant]
SELECT a.insurance_provider,
       a.plan_id AS plan_id_1,
       a.plan_type AS type_1,
       b.plan_id AS plan_id_2,
       b.plan_type AS type_2
FROM healthcare.insurance_plans a
JOIN healthcare.insurance_plans b
  ON a.insurance_provider = b.insurance_provider
 AND a.plan_type <> b.plan_type
 AND a.plan_id < b.plan_id
WHERE a.insurance_provider IN (
  SELECT insurance_provider
  FROM healthcare.insurance_plans
  GROUP BY insurance_provider
  HAVING COUNT(DISTINCT plan_type) >= 3
);


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

[User] Show me the total quantity traded and total amount for each security, identified by its ticker symbol, for trades in the last month.

[Assistant] SELECT T2.ticker_symbol, SUM(T1.quantity), SUM(T1.total_amount) FROM financial_services.trades AS T1 JOIN financial_services.securities AS T2 ON T1.security_id = T2.security_id WHERE T1.trade_timestamp >= DATE('now', '-1 month') GROUP BY 1

[User] Can you also show the average price per unit and filter to only include securities where the total quantity traded is greater than 5000?

[Assistant] SELECT T2.ticker_symbol, SUM(T1.quantity), SUM(T1.total_amount), AVG(T1.price_per_unit) FROM financial_services.trades AS T1 JOIN financial_services.securities AS T2 ON T1.security_id = T2.security_id WHERE T1.trade_timestamp >= DATE('now', '-1 month') GROUP BY 1 HAVING SUM(T1.quantity) > 5000


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
 "CREATE TABLE narrative_info (",
    "narrative character varying(512) NOT NULL, -- the id of narrative",
    "top_3_coins text, -- the top 3 tokens in the narrative",
    "price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour in the narrative",
    "price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours in the narrative",
    "price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days in the narrative",
    "market_cap double precision, -- the market cap of the narrative",
    "volume_24h double precision, -- the trade volume of the narrative",
    "trend_rank bigint, -- the trending rank of the narrative, value 1 expresses the most popular narrative",
    "token_num bigint, -- total token number in the narrative",
    ",PRIMARY KEY (narrative));"

  "CREATE TABLE cex_token_balance (",
    "snapshot_time character varying(32) NOT NULL,  -- the snapshot time of record, converted from original timestamp",
    "chain character varying(128) NOT NULL, -- the chain that the token resides",
    "address character varying(128) NOT NULL, -- the address that holds the assets, owned by a CEX",
    "exchange character varying(512) NOT NULL, -- a centralized exchange name",
    "token_address character varying(128) NOT NULL, -- token contract address",
    "token_symbol character varying(512), --token symbol",
    "balance numeric(38,10), -- token balance",
    "usd_value numeric(38,14), -- value of the token held in USD",
    "price double precision, --price of the token in USD",
    ",PRIMARY KEY (snapshot_time, exchange, address, chain, token_address));"

  "CREATE TABLE smart_money_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));",

  "CREATE 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)",

[User] Which smart money address on the 'Ethereum' chain has the highest profit from tokens in the 'DeFi' narrative, and what is their ROI?

[Assistant]
SELECT sm.address, sm.profit, sm.roi
FROM smart_money_profit sm
JOIN smart_money_token_inflow si ON sm.address = si.address AND sm.chain = si.chain
WHERE sm.chain = 'Ethereum' AND si.narrative = 'DeFi'
ORDER BY sm.profit DESC
LIMIT 1;

[User] Could you include the most profitable token for each address in the result?

[Assistant]
SELECT sm.address, sm.profit, sm.roi, sm.most_profit_token
FROM smart_money_profit sm
JOIN smart_money_token_inflow si ON sm.address = si.address AND sm.chain = si.chain
WHERE sm.chain = 'Ethereum' AND si.narrative = 'DeFi'
ORDER BY sm.profit DESC
LIMIT 1;

[User] Now, only show addresses with ROI above 10.

[Assistant]
SELECT sm.address, sm.profit, sm.roi, sm.most_profit_token
FROM smart_money_profit sm
JOIN smart_money_token_inflow si ON sm.address = si.address AND sm.chain = si.chain
WHERE sm.chain = 'Ethereum' AND si.narrative = 'DeFi' AND sm.roi > 10
ORDER BY sm.profit DESC;

[User] Order the results by ROI descending and show the top 2.

[Assistant]
SELECT sm.address, sm.profit, sm.roi, sm.most_profit_token
FROM smart_money_profit sm
JOIN smart_money_token_inflow si ON sm.address = si.address AND sm.chain = si.chain
WHERE sm.chain = 'Ethereum' AND si.narrative = 'DeFi' AND sm.roi > 10
ORDER BY sm.roi DESC
LIMIT 2;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE hospitality_technology.properties (
    property_id character varying(64) NOT NULL,  -- unique identifier for the property (hotel, resort, etc.)
    property_name character varying(255) NOT NULL, -- name of the property
    address_line1 character varying(255) NOT NULL, -- primary address line
    address_line2 character varying(255), -- secondary address line
    city character varying(100) NOT NULL, -- city
    state_province character varying(100), -- state or province
    postal_code character varying(20) NOT NULL, -- zip or postal code
    country_code character varying(3) NOT NULL, -- ISO country code (e.g., USA, CAN)
    phone_number character varying(30), -- main contact phone
    email_address character varying(255), -- main contact email
    property_type character varying(50) NOT NULL, -- e.g., Hotel, Resort, B&B, Motel
    star_rating numeric(2,1), -- star rating (e.g., 4.5)
    timezone character varying(64) NOT NULL, -- IANA timezone ID (e.g., America/New_York)
    manager_staff_id character varying(64), -- FK to staff table for the general manager
    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record creation time
    updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp, -- record last update time
    PRIMARY KEY (property_id)
)
CREATE TABLE hospitality_technology.staff ( staff_id text PRIMARY KEY, property_id text, first_name text, last_name text, position text, work_email text, work_phone text, hire_date date, termination_date date, is_active boolean, access_level int, manager_id text, created_at timestamp )
CREATE TABLE hospitality_technology.service_orders ( order_id text PRIMARY KEY, reservation_id text, guest_id text, service_id text, staff_id_ordered text, staff_id_delivered text, order_timestamp timestamp, delivery_timestamp timestamp, quantity int, unit_price numeric, total_price numeric, status text, notes text, bill_id text )
CREATE TABLE hospitality_technology.reviews ( review_id text, property_id text, reservation_id text, guest_id text, rating_overall integer, rating_cleanliness integer, rating_service integer, rating_location integer, rating_value integer, comment text, review_source text, review_date timestamp, is_public boolean, staff_response text, response_staff_id text, response_date timestamp )

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

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

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

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


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE government_services.agencies ( agency_id character varying(64) NOT NULL, agency_name character varying(255) NOT NULL, jurisdiction_level character varying(50) NOT NULL, primary_contact_email character varying(128), main_phone_number character varying(32), website_url character varying(255), established_date date, parent_agency_id character varying(64), PRIMARY KEY (agency_id) )
CREATE TABLE government_services.applications (
    application_id character varying(64) NOT NULL, -- unique identifier for the application
    citizen_id character varying(64) NOT NULL, -- FK to citizens table
    service_id character varying(64) NOT NULL, -- FK to services table
    submitted_at timestamp NOT NULL, -- time the application was submitted
    status character varying(50) NOT NULL, -- e.g., Submitted, Processing, Approved, Rejected, Pending Info
    last_updated_at timestamp NOT NULL, -- time the status or details last changed
    assigned_employee_id character varying(64), -- FK to employees table (optional)
    decision_date date, -- date when a final decision was made
    notes text, -- internal notes or citizen-provided comments
    reference_number character varying(100) UNIQUE, -- publicly visible reference number
    PRIMARY KEY (application_id)
)
CREATE TABLE government_services.documents ( document_id text PRIMARY KEY, application_id text, citizen_id text, document_type text, file_reference text, upload_timestamp timestamp, expiry_date date, verification_status text, verified_by_employee_id text, verification_timestamp timestamp )
CREATE TABLE government_services.employees (
    employee_id character varying(64) NOT NULL, -- unique identifier for the government employee
    agency_id character varying(64) NOT NULL, -- FK to agencies table
    first_name character varying(100) NOT NULL,
    last_name character varying(100) NOT NULL,
    job_title character varying(150) NOT NULL,
    department character varying(100),
    work_email character varying(128) NOT NULL UNIQUE,
    work_phone character varying(32),
    hire_date date NOT NULL,
    termination_date date, -- null if currently employed
    access_level character varying(50), -- Role or permission level
    manager_employee_id character varying(64), -- FK to self for reporting structure
    PRIMARY KEY (employee_id)
)
CREATE TABLE government_services.appointments ( appointment_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, employee_id character varying(64), location_id character varying(64), service_id character varying(64), scheduled_start_time timestamp NOT NULL, scheduled_end_time timestamp, purpose text NOT NULL, status character varying(30) NOT NULL, booking_method character varying(50), created_at timestamp NOT NULL, notes text, PRIMARY KEY (appointment_id) )

[User] List the reference number and status for all applications that have at least one document associated with them.

[Assistant] SELECT DISTINCT a.reference_number, a.status FROM government_services.applications AS a JOIN government_services.documents AS d ON a.application_id = d.application_id


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE 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) )
CREATE TABLE transportation.routes ( route_id character varying(64) NOT NULL, route_number character varying(32) NOT NULL UNIQUE, description text, origin_location_id character varying(64) NOT NULL, destination_location_id character varying(64) NOT NULL, distance_km numeric(10, 2), estimated_duration_minutes integer, type character varying(32) NOT NULL, PRIMARY KEY (route_id) )
CREATE 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) )
CREATE TABLE transportation.maintenance_logs ( log_id character varying(64) NOT NULL, vehicle_id character varying(64) NOT NULL, service_date date NOT NULL, odometer_reading integer, service_type character varying(128) NOT NULL, description text NOT NULL, cost numeric(10, 2), mechanic_name character varying(128), next_service_due_date date, PRIMARY KEY (log_id) )
CREATE 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) )

[User] List all routes along with the number of unique vehicles assigned to trips on each route.

[Assistant]
SELECT r.route_id, r.route_number, COUNT(DISTINCT t.vehicle_id) AS unique_vehicles
FROM transportation.routes r
LEFT JOIN transportation.trips t ON r.route_id = t.route_id
GROUP BY r.route_id, r.route_number;

[User] Can you add the average passenger count per trip for each route as well?

[Assistant]
SELECT r.route_id, r.route_number, COUNT(DISTINCT t.vehicle_id) AS unique_vehicles, AVG(t.passenger_count) AS avg_passenger_count
FROM transportation.routes r
LEFT JOIN transportation.trips t ON r.route_id = t.route_id
GROUP BY r.route_id, r.route_number;

[User] Only show routes where there have been more than 5 trips.

[Assistant]
SELECT r.route_id, r.route_number, COUNT(DISTINCT t.vehicle_id) AS unique_vehicles, AVG(t.passenger_count) AS avg_passenger_count, COUNT(t.trip_id) AS total_trips
FROM transportation.routes r
LEFT JOIN transportation.trips t ON r.route_id = t.route_id
GROUP BY r.route_id, r.route_number
HAVING COUNT(t.trip_id) > 5;

[User] Please also include the route type and order the results by the average passenger count in descending order.

[Assistant]
SELECT r.route_id, r.route_number, r.type AS route_type, COUNT(DISTINCT t.vehicle_id) AS unique_vehicles, AVG(t.passenger_count) AS avg_passenger_count, COUNT(t.trip_id) AS total_trips
FROM transportation.routes r
LEFT JOIN transportation.trips t ON r.route_id = t.route_id
GROUP BY r.route_id, r.route_number, r.type
HAVING COUNT(t.trip_id) > 5
ORDER BY avg_passenger_count DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE social_media.posts ( post_id text PRIMARY KEY, user_id text, content text, media_url text, media_type text, created_at timestamp, updated_at timestamp, visibility text, location_lat numeric, location_lon numeric )
CREATE TABLE social_media.comments ( comment_id text PRIMARY KEY, post_id text, user_id text, parent_comment_id text, content text, created_at timestamp, updated_at timestamp )
CREATE TABLE social_media.likes ( like_id text PRIMARY KEY, user_id text, post_id text, comment_id text, created_at timestamp )
CREATE TABLE social_media.follows ( follow_id text PRIMARY KEY, follower_user_id text, following_user_id text, created_at timestamp )
CREATE TABLE social_media.hashtags ( hashtag_id text PRIMARY KEY, tag_name text, created_at timestamp )
CREATE TABLE social_media.post_hashtags ( post_hashtag_id text PRIMARY KEY, post_id text, hashtag_id text )
CREATE TABLE social_media.messages ( message_id text PRIMARY KEY, conversation_id text, sender_user_id text, content text, media_url text, media_type text, sent_at timestamp, read_at timestamp )
CREATE TABLE social_media.conversation_participants ( participant_id text PRIMARY KEY, conversation_id text, user_id text, joined_at timestamp, last_read_at timestamp )
CREATE TABLE social_media.user_settings ( setting_id text PRIMARY KEY, user_id text, theme text, email_notifications_enabled bool, push_notifications_enabled bool, private_profile bool, updated_at timestamp )

[User] List the usernames of users who have joined a conversation and sent at least one message in it. Include the conversation_id for each.

[Assistant]
SELECT DISTINCT u.username, cp.conversation_id
FROM social_media.conversation_participants cp
JOIN social_media.users u ON cp.user_id = u.user_id
JOIN social_media.messages m ON cp.conversation_id = m.conversation_id AND cp.user_id = m.sender_user_id;

[User] Can you also show the number of messages each user sent in those conversations as message_count?

[Assistant]
SELECT u.username, cp.conversation_id, COUNT(m.message_id) AS message_count
FROM social_media.conversation_participants cp
JOIN social_media.users u ON cp.user_id = u.user_id
JOIN social_media.messages m ON cp.conversation_id = m.conversation_id AND cp.user_id = m.sender_user_id
GROUP BY u.username, cp.conversation_id;

[User] Please only include users who sent more than 5 messages in a conversation.

[Assistant]
SELECT u.username, cp.conversation_id, COUNT(m.message_id) AS message_count
FROM social_media.conversation_participants cp
JOIN social_media.users u ON cp.user_id = u.user_id
JOIN social_media.messages m ON cp.conversation_id = m.conversation_id AND cp.user_id = m.sender_user_id
GROUP BY u.username, cp.conversation_id
HAVING COUNT(m.message_id) > 5;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE social_media.comments ( comment_id text, post_id text, user_id text, parent_comment_id text, content text, created_at timestamp, updated_at timestamp )
CREATE TABLE social_media.hashtags ( hashtag_id text, tag_name text, created_at timestamp )
CREATE TABLE social_media.conversations ( conversation_id text PRIMARY KEY, created_at timestamp, last_message_at timestamp, is_group_chat bool, group_name text )

[User] Show me all replies to comments on post 'P500', including the reply content and the content of the parent comment.

[Assistant] SELECT T1.content AS reply_content, T2.content AS parent_comment_content FROM social_media.comments AS T1 JOIN social_media.comments AS T2 ON T1.parent_comment_id = T2.comment_id WHERE T1.post_id = 'P500'

[User] Only include replies created after '2024-06-15'.

[Assistant] SELECT T1.content AS reply_content, T2.content AS parent_comment_content FROM social_media.comments AS T1 JOIN social_media.comments AS T2 ON T1.parent_comment_id = T2.comment_id WHERE T1.post_id = 'P500' AND T1.created_at > '2024-06-15'

[User] Also, only show replies where the parent comment content contains the word 'question'.

[Assistant] SELECT T1.content AS reply_content, T2.content AS parent_comment_content FROM social_media.comments AS T1 JOIN social_media.comments AS T2 ON T1.parent_comment_id = T2.comment_id WHERE T1.post_id = 'P500' AND T1.created_at > '2024-06-15' AND T2.content LIKE '%question%'

[User] Order the results by reply creation time descending and limit to 10.

[Assistant] SELECT T1.content AS reply_content, T2.content AS parent_comment_content FROM social_media.comments AS T1 JOIN social_media.comments AS T2 ON T1.parent_comment_id = T2.comment_id WHERE T1.post_id = 'P500' AND T1.created_at > '2024-06-15' AND T2.content LIKE '%question%' ORDER BY T1.created_at DESC LIMIT 10


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

[User] Show me all services, their names, and their online application URLs for services that are both active and have an online application available.

[Assistant] SELECT service_name, online_application_url FROM government_services.services WHERE is_active = TRUE AND online_application_url IS NOT NULL AND online_application_url <> '';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE 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 )
CREATE TABLE financial_services.employees ( employee_id text PRIMARY KEY, first_name text, last_name text, job_title text, department text, branch_id text, email text, phone_extension text, hire_date date, termination_date date, manager_id text, status text )

[User] Give me the number of securities and the latest update timestamp for each security_type.

[Assistant]
SELECT security_type,
       COUNT(*) AS security_count,
       MAX(last_updated) AS latest_update
FROM financial_services.securities
GROUP BY security_type;

[User] Now only show types with more than 10 securities.

[Assistant]
SELECT security_type,
       COUNT(*) AS security_count,
       MAX(last_updated) AS latest_update
FROM financial_services.securities
GROUP BY security_type
HAVING COUNT(*) > 10;

[User] Sort the output by latest_update ascending.

[Assistant]
SELECT security_type,
       COUNT(*) AS security_count,
       MAX(last_updated) AS latest_update
FROM financial_services.securities
GROUP BY security_type
HAVING COUNT(*) > 10
ORDER BY latest_update ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.patients ( patient_id.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 )
CREATE 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) )
CREATE TABLE healthcare.insurance_plans ( plan_id text PRIMARY KEY, plan_name text, insurance_provider text, plan_type text, contact_phone text, website text )

[User] Show all diagnoses recorded by doctor with ID 'doc789'. Include the diagnosis ID, patient ID, description, and diagnosis date.

[Assistant] SELECT diagnosis_id, patient_id, description, diagnosis_date FROM healthcare.diagnoses WHERE doctor_id = 'doc789';

[User] Also include the patient's full name (first and last name) for each of these diagnoses.

[Assistant] SELECT d.diagnosis_id, d.patient_id, p.first_name AS patient_first_name, p.last_name AS patient_last_name, d.description, d.diagnosis_date FROM healthcare.diagnoses d JOIN healthcare.patients p ON d.patient_id = p.patient_id WHERE d.doctor_id = 'doc789';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.doctors ( doctor_id text, first_name text, last_name text, specialty text, license_number text, phone_number text, email text, hospital_affiliation_id text, created_at timestamp, updated_at timestamp )
CREATE TABLE healthcare.diagnoses (
    diagnosis_id character varying(64) NOT NULL, -- unique identifier for the diagnosis entry
    record_id character varying(64) NOT NULL, -- FK linking to the specific medical record entry
    patient_id character varying(64) NOT NULL, -- FK to patients table
    doctor_id character varying(64) NOT NULL, -- FK to doctors table (diagnosing doctor)
    diagnosis_code character varying(20) NOT NULL, -- standard code (e.g., ICD-10)
    code_type character varying(10) NOT NULL DEFAULT 'ICD-10', -- type of code used
    description text, -- textual description of the diagnosis
    diagnosis_date date NOT NULL, -- date the diagnosis was made
    status character varying(32) NOT NULL, -- e.g., Active, Resolved, Ruled Out
    is_chronic boolean DEFAULT false, -- flag for chronic conditions
    PRIMARY KEY (diagnosis_id)
)
CREATE TABLE healthcare.insurance_plans ( plan_id text, plan_name text, insurance_provider text, plan_type text, contact_phone text, website text )

[User] Get a list of all distinct specialties found among the doctors.

[Assistant] SELECT DISTINCT specialty FROM healthcare.doctors;


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

[User] List the full names and hire dates of all employees who report directly to a manager with the job title 'Director'.

[Assistant]
SELECT e.first_name, e.last_name, e.hire_date
FROM government_services.employees e
JOIN government_services.employees m ON e.manager_employee_id = m.employee_id
WHERE m.job_title = 'Director';


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

[User] Show me the top 5 guests who have submitted the most reviews. Include guest_id and review_count.

[Assistant]
SELECT guest_id, COUNT(*) AS review_count
FROM hospitality_technology.reviews
GROUP BY guest_id
ORDER BY review_count DESC
LIMIT 5;

[User] Also include their highest overall rating given in any review.

[Assistant]
SELECT guest_id, COUNT(*) AS review_count, MAX(rating_overall) AS max_rating_overall
FROM hospitality_technology.reviews
GROUP BY guest_id
ORDER BY review_count DESC
LIMIT 5;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE gaming_technology.player_achievements ( player_achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), player_id uuid NOT NULL, achievement_id uuid NOT NULL, unlocked_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (player_achievement_id), UNIQUE (player_id, achievement_id) )

[User] List all pairs of players who unlocked the same achievement, showing achievement_id, player1_id, player2_id, and player1_unlocked_at.

[Assistant]
SELECT pa1.achievement_id,
       pa1.player_id AS player1_id,
       pa2.player_id AS player2_id,
       pa1.unlocked_at AS player1_unlocked_at
FROM gaming_technology.player_achievements pa1
JOIN gaming_technology.player_achievements pa2
  ON pa1.achievement_id = pa2.achievement_id;

[User] Ensure each pair appears only once by requiring player1_id < player2_id.

[Assistant]
SELECT pa1.achievement_id,
       pa1.player_id AS player1_id,
       pa2.player_id AS player2_id,
       pa1.unlocked_at AS player1_unlocked_at
FROM gaming_technology.player_achievements pa1
JOIN gaming_technology.player_achievements pa2
  ON pa1.achievement_id = pa2.achievement_id
WHERE pa1.player_id < pa2.player_id;

[User] And only include pairs where the two unlocks occurred within one hour of each other.

[Assistant]
SELECT pa1.achievement_id,
       pa1.player_id AS player1_id,
       pa2.player_id AS player2_id,
       pa1.unlocked_at AS player1_unlocked_at,
       pa2.unlocked_at AS player2_unlocked_at
FROM gaming_technology.player_achievements pa1
JOIN gaming_technology.player_achievements pa2
  ON pa1.achievement_id = pa2.achievement_id
WHERE pa1.player_id < pa2.player_id
  AND ABS(EXTRACT(EPOCH FROM (pa1.unlocked_at - pa2.unlocked_at))) <= 3600;


System:
You are an expert in writing database language and you can refuse the user's question if the question is not related to the table structure. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE train_station_management.train_cars ( car_id character varying(64) NOT NULL, train_id character varying(64) NOT NULL, car_number character varying(10) NOT NULL, car_type character varying(64) NOT NULL, class character varying(32), capacity integer, features text, PRIMARY KEY (car_id), FOREIGN KEY (train_id) REFERENCES train_station_management.trains(train_id) )

[User] What is the maintenance schedule for the train car with car_id 'CAR456'?

[Assistant] I'm sorry, but I can't provide information about the maintenance schedule for train cars as it is not included in the data available in the train_cars table.


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

[User] Display each product alongside the most recently updated product of the same type. Return original_id, original_updated_at, recent_id, recent_updated_at, and product_type.

[Assistant] SELECT p.product_id AS original_id, p.updated_at AS original_updated_at, r.product_id AS recent_id, r.updated_at AS recent_updated_at, p.product_type FROM insurance.insurance_products p JOIN (SELECT product_type, MAX(updated_at) AS max_updated FROM insurance.insurance_products GROUP BY product_type) m ON p.product_type = m.product_type JOIN insurance.insurance_products r ON r.product_type = p.product_type AND r.updated_at = m.max_updated;

[User] Actually, exclude entries where original or recent updated_at is null.

[Assistant] SELECT p.product_id AS original_id, p.updated_at AS original_updated_at, r.product_id AS recent_id, r.updated_at AS recent_updated_at, p.product_type FROM insurance.insurance_products p JOIN (SELECT product_type, MAX(updated_at) AS max_updated FROM insurance.insurance_products WHERE updated_at IS NOT NULL GROUP BY product_type) m ON p.product_type = m.product_type AND p.updated_at IS NOT NULL JOIN insurance.insurance_products r ON r.product_type = p.product_type AND r.updated_at = m.max_updated;

[User] Also, only include product types that have more than 2 products.

[Assistant] SELECT p.product_id AS original_id, p.updated_at AS original_updated_at, r.product_id AS recent_id, r.updated_at AS recent_updated_at, p.product_type FROM insurance.insurance_products p JOIN (SELECT product_type, MAX(updated_at) AS max_updated FROM insurance.insurance_products WHERE updated_at IS NOT NULL GROUP BY product_type) m ON p.product_type = m.product_type AND p.updated_at IS NOT NULL JOIN insurance.insurance_products r ON r.product_type = p.product_type AND r.updated_at = m.max_updated WHERE p.product_type IN (SELECT product_type FROM insurance.insurance_products GROUP BY product_type HAVING COUNT(*) > 2);

[User] Finally, sort the results by recent_updated_at descending.

[Assistant] SELECT p.product_id AS original_id, p.updated_at AS original_updated_at, r.product_id AS recent_id, r.updated_at AS recent_updated_at, p.product_type FROM insurance.insurance_products p JOIN (SELECT product_type, MAX(updated_at) AS max_updated FROM insurance.insurance_products WHERE updated_at IS NOT NULL GROUP BY product_type) m ON p.product_type = m.product_type AND p.updated_at IS NOT NULL JOIN insurance.insurance_products r ON r.product_type = p.product_type AND r.updated_at = m.max_updated WHERE p.product_type IN (SELECT product_type FROM insurance.insurance_products GROUP BY product_type HAVING COUNT(*) > 2) ORDER BY recent_updated_at DESC;


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

[User] What is the average processing time in days for each service category?

[Assistant]
SELECT category, AVG(average_processing_time_days) AS avg_processing_time
FROM government_services.services
GROUP BY category;

[User] Only include categories where the average_processing_time_days is greater than 5.

[Assistant]
SELECT category, AVG(average_processing_time_days) AS avg_processing_time
FROM government_services.services
GROUP BY category
HAVING AVG(average_processing_time_days) > 5;

[User] Also include only active services in the calculation.

[Assistant]
SELECT category, AVG(average_processing_time_days) AS avg_processing_time
FROM government_services.services
WHERE is_active = TRUE
GROUP BY category
HAVING AVG(average_processing_time_days) > 5;

[User] Sort the results by avg_processing_time in descending order.

[Assistant]
SELECT category, AVG(average_processing_time_days) AS avg_processing_time
FROM government_services.services
WHERE is_active = TRUE
GROUP BY category
HAVING AVG(average_processing_time_days) > 5
ORDER BY avg_processing_time DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )

[User] List the plan ID, name, provider, and type for all insurance plans from 'Healthcare Partners' with a plan type of 'PPO'.

[Assistant] SELECT plan_id, plan_name, insurance_provider, plan_type FROM healthcare.insurance_plans WHERE insurance_provider = 'Healthcare Partners' AND plan_type = 'PPO';

[User] Now, only show those plans that also have a website listed.

[Assistant] SELECT plan_id, plan_name, insurance_provider, plan_type FROM healthcare.insurance_plans WHERE insurance_provider = 'Healthcare Partners' AND plan_type = 'PPO' AND website IS NOT NULL;

[User] Further refine the results to only include plans where the plan name contains the word 'Plus'.

[Assistant] SELECT plan_id, plan_name, insurance_provider, plan_type FROM healthcare.insurance_plans WHERE insurance_provider = 'Healthcare Partners' AND plan_type = 'PPO' AND website IS NOT NULL AND plan_name ILIKE '%Plus%';

[User] Finally, count how many such plans exist.

[Assistant] SELECT COUNT(*) FROM healthcare.insurance_plans WHERE insurance_provider = 'Healthcare Partners' AND plan_type = 'PPO' AND website IS NOT NULL AND plan_name ILIKE '%Plus%';


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

[User] Retrieve the first and last names and email addresses of all customers who registered after '2024-01-01'.

[Assistant] SELECT first_name, last_name, email FROM insurance.customers WHERE created_at > '2024-01-01';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.wallets ( wallet_id.text, user_id.text, address.text, private_key.text, created_at.timestamp )
CREATE 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 )
CREATE TABLE trading_platform.utxos ( utxo_id.text, transaction_id.text, output_index.integer, address.text, amount.numeric, spent.boolean )
CREATE TABLE trading_platform.dapps ( dapp_id.text, name.text, description.text, url.text )
CREATE TABLE trading_platform.peers ( peer_id.text, ip_address.text, port.integer, last_seen.timestamp )
CREATE TABLE trading_platform.logs ( log_id.text, user_id.text, action.text, details.text, logged_at.timestamp )

[User] List all unspent UTXOs with an amount greater than 10.

[Assistant] SELECT utxo_id, transaction_id, address, amount FROM utxos WHERE spent = FALSE AND amount > 10;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE project_fundraising_record ( id character varying(32) NOT NULL, project_id character varying(32) NOT NULL, project_name character varying(128) NOT NULL, rounds_name character varying(32), investment_value numeric(38,14), investment_date character varying(128), introduction character varying(128), valuation numeric(38,14) )
CREATE TABLE token_basic_info ( coin_id text, token_name text, token_symbol text, token_address text, chain text, price numeric, price_change_percentage_1h numeric, price_change_percentage_24h numeric, price_change_percentage_7d numeric, highest_price_24h numeric, lowest_price_24h numeric, market_cap numeric, market_cap_rank numeric, market_cap_change_percentage_24h text, total_volume text, narrative text, trend_rank numeric )
 "CREATE TABLE narrative_info (",
    "narrative character varying(512) NOT NULL, -- the id of narrative",
    "top_3_coins text, -- the top 3 tokens in the narrative",
    "price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour in the narrative",
    "price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours in the narrative",
    "price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days in the narrative",
    "market_cap double precision, -- the market cap of the narrative",
    "volume_24h double precision, -- the trade volume of the narrative",
    "trend_rank bigint, -- the trending rank of the narrative, value 1 expresses the most popular narrative",
    "token_num bigint, -- total token number in the narrative",
    ",PRIMARY KEY (narrative));"

CREATE TABLE token_dexpool_info ( pair_address character varying(512) NOT NULL, -- the id of dexpool token_name character varying(100) NOT NULL, -- the name of the token in the dexpool token_symbol character varying(100) NOT NULL, -- the token's symbol chain text, -- the chain that the dexpool resides price double precision, -- the current price of the token price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour price_change_percentage_6h double precision, -- change in value divided by the absolute price value of the original token price in 6 hours price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours makers_24h double precision, -- the makers of the dex pool in 24 hours volume_24h double precision, -- the trade volume of the dex pool in 24 hours liquidity double precision, -- the liquidity of the dex pool market_cap double precision, -- the market cap of the token trend_rank bigint, -- the rank of token in the dex pool of recent trending, value 1 expresses the most popular token. ,PRIMARY KEY (pair_address, chain) )
  "CREATE TABLE cex_token_balance (",
    "snapshot_time character varying(32) NOT NULL,  -- the snapshot time of record, converted from original timestamp",
    "chain character varying(128) NOT NULL, -- the chain that the token resides",
    "address character varying(128) NOT NULL, -- the address that holds the assets, owned by a CEX",
    "exchange character varying(512) NOT NULL, -- a centralized exchange name",
    "token_address character varying(128) NOT NULL, -- token contract address",
    "token_symbol character varying(512), --token symbol",
    "balance numeric(38,10), -- token balance",
    "usd_value numeric(38,14), -- value of the token held in USD",
    "price double precision, --price of the token in USD",
    ",PRIMARY KEY (snapshot_time, exchange, address, chain, token_address));"

CREATE TABLE smart_money_token_performance ( token_address text, token_symbol text, pnl numeric, net_flow numeric, avg_cost numeric, price numeric, realized_ratio numeric, roi numeric, chain text )
CREATE TABLE smart_money_token_inflow ( token_address text, token_symbol text, token_amount numeric, usd_value numeric, avg_price numeric, type numeric, address_amount numeric, narrative text, chain text )

[User] For each narrative in token_basic_info, compute the total liquidity and count of tokens from token_dexpool_info. Show narrative, total_liquidity, and token_count.

[Assistant]
SELECT tbi.narrative,
  SUM(td.liquidity) AS total_liquidity,
  COUNT(DISTINCT td.token_symbol) AS token_count
FROM token_basic_info tbi
JOIN token_dexpool_info td
  ON tbi.token_address = td.token_address
GROUP BY tbi.narrative;

[User] Include only tokens where volume_24h > 500000 and price_change_percentage_6h > 0.

[Assistant]
SELECT tbi.narrative,
  SUM(td.liquidity) AS total_liquidity,
  COUNT(DISTINCT td.token_symbol) AS token_count
FROM token_basic_info tbi
JOIN token_dexpool_info td
  ON tbi.token_address = td.token_address
WHERE td.volume_24h > 500000
  AND td.price_change_percentage_6h > 0
GROUP BY tbi.narrative;

[User] Now join narrative_info to also get trend_rank and narrative volume_24h.

[Assistant]
SELECT tbi.narrative,
  ni.trend_rank,
  ni.volume_24h AS narrative_volume,
  SUM(td.liquidity) AS total_liquidity,
  COUNT(DISTINCT td.token_symbol) AS token_count
FROM token_basic_info tbi
JOIN token_dexpool_info td
  ON tbi.token_address = td.token_address
JOIN narrative_info ni
  ON tbi.narrative = ni.narrative
WHERE td.volume_24h > 500000
  AND td.price_change_percentage_6h > 0
GROUP BY tbi.narrative, ni.trend_rank, ni.volume_24h;

[User] Finally, only keep narratives where trend_rank <= 10 and order by total_liquidity descending.

[Assistant]
SELECT tbi.narrative,
  ni.trend_rank,
  ni.volume_24h AS narrative_volume,
  SUM(td.liquidity) AS total_liquidity,
  COUNT(DISTINCT td.token_symbol) AS token_count
FROM token_basic_info tbi
JOIN token_dexpool_info td
  ON tbi.token_address = td.token_address
JOIN narrative_info ni
  ON tbi.narrative = ni.narrative
WHERE td.volume_24h > 500000
  AND td.price_change_percentage_6h > 0
  AND ni.trend_rank <= 10
GROUP BY tbi.narrative, ni.trend_rank, ni.volume_24h
ORDER BY total_liquidity DESC;