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.achievements (
    achievement_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for an achievement definition
    game_id uuid NOT NULL, -- FK linking to the game the achievement belongs to
    name character varying(150) NOT NULL, -- name of the achievement
    description text NOT NULL, -- how to unlock the achievement
    icon_url character varying(255), -- URL for the achievement's icon
    points integer DEFAULT 0, -- points awarded for unlocking (optional)
    hidden boolean DEFAULT false, -- whether the achievement details are hidden until unlocked
    PRIMARY KEY (achievement_id)
    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)
)
##Table Structure
CREATE TABLE web3.token_transfers ( transfer_id character varying(64) NOT NULL, token_id character varying(64) NOT NULL, from_address character varying(128) NOT NULL, to_address character varying(128) NOT NULL, value numeric(38,14) NOT NULL, transaction_id character varying(64) NOT NULL, log_index integer NOT NULL, PRIMARY KEY (transfer_id) )
##Table Structure
CREATE TABLE social_media.posts ( post_id text, user_id text, content text, media_url text, media_type text, created_at timestamp, updated_at timestamp, visibility text, location_lat numeric, location_lon numeric )
##Table Structure
CREATE TABLE healthcare.diagnoses ( diagnosis_id text, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )
##Table Structure
CREATE TABLE web3.tokens (
    token_id character varying(64) NOT NULL,  -- unique identifier for the token
    contract_address character varying(128) NOT NULL, -- address of the token contract
    token_name character varying(128) NOT NULL, -- name of the token
    token_symbol character varying(32) NOT NULL, -- symbol of the token
    decimals integer NOT NULL, -- number of decimals for the token
    total_supply numeric(38,14) NOT NULL, -- total supply of the token
    PRIMARY KEY (token_id)
)
CREATE TABLE web3.token_transfers (
    transfer_id character varying(64) NOT NULL,  -- unique identifier for the transfer
    token_id character varying(64) NOT NULL, -- identifier of the token being transferred
    from_address character varying(128) NOT NULL, -- address of the sender
    to_address character varying(128) NOT NULL, -- address of the receiver
    value numeric(38,14) NOT NULL, -- amount of tokens transferred
    transaction_id character varying(64) NOT NULL, -- identifier of the transaction containing the transfer
    log_index integer NOT NULL, -- index of the transfer log in the transaction
    PRIMARY KEY (transfer_id)
)
CREATE TABLE web3.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)
)
##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 )
##Table Structure
CREATE TABLE social_media.user_settings ( setting_id.text, user_id.text, theme.text, email_notifications_enabled.boolean, push_notifications_enabled.boolean, private_profile.boolean, updated_at.timestamp )

[User] Show me the count of achievements that are hidden versus those that are not hidden.

[Assistant] SELECT hidden, COUNT(*) FROM achievements GROUP BY hidden;

[User] Include the average points for each group as well.

[Assistant] SELECT hidden, COUNT(*), AVG(points) FROM achievements GROUP BY hidden;

[User] Could you also add the average length of the description for each group?

[Assistant] SELECT hidden, COUNT(*), AVG(points), AVG(LENGTH(description)) FROM achievements GROUP BY hidden;

[User] Filter the results to only show groups that have more than 5 achievements.

[Assistant] SELECT hidden, COUNT(*), AVG(points), AVG(LENGTH(description)) FROM achievements GROUP BY hidden HAVING COUNT(*) > 5;

[User] List pairs of transfer IDs that occurred sequentially (log_index difference is 1) within the same transaction. Show the transaction ID, the first transfer ID, the second transfer ID, and their log indices.

[Assistant] SELECT t1.transaction_id, t1.transfer_id AS first_transfer_id, t2.transfer_id AS second_transfer_id, t1.log_index AS first_log_index, t2.log_index AS second_log_index FROM web3.token_transfers t1 JOIN web3.token_transfers t2 ON t1.transaction_id = t2.transaction_id AND t2.log_index = t1.log_index + 1;

[User] Show the count of posts for each distinct media type.

[Assistant] SELECT media_type, COUNT(*) FROM social_media.posts GROUP BY media_type;

[User] Only include posts created after June 1, 2024.

[Assistant] SELECT media_type, COUNT(*) FROM social_media.posts WHERE created_at >= '2024-06-01' GROUP BY media_type;

[User] List the diagnosis ID, description, and diagnosis date for all non-chronic diagnoses recorded for patient 'pat123'.

[Assistant] SELECT diagnosis_id, description, diagnosis_date FROM healthcare.diagnoses WHERE patient_id = 'pat123' AND is_chronic = false;

[User] Okay, now show me the count of non-chronic diagnoses for patient 'pat123' for each doctor who has also recorded at least one *chronic* diagnosis for that same patient. Display the doctor ID and the count of non-chronic diagnoses.

[Assistant] SELECT d1.doctor_id, COUNT(d1.diagnosis_id) AS non_chronic_count FROM healthcare.diagnoses d1 WHERE d1.patient_id = 'pat123' AND d1.is_chronic = false AND EXISTS (SELECT 1 FROM healthcare.diagnoses d2 WHERE d2.patient_id = d1.patient_id AND d2.doctor_id = d1.doctor_id AND d2.is_chronic = true) GROUP BY d1.doctor_id;

[User] List each wallet that has received tokens of more than one distinct token type. Show wallet_id, address, the number of distinct tokens received as distinct_token_count, and the total received value, ordered by total_received_value descending.

[Assistant]
SELECT w.wallet_id,
       w.address,
       COUNT(DISTINCT t.token_id) AS distinct_token_count,
       SUM(tt.value)            AS total_received_value
FROM web3.wallets w
JOIN web3.token_transfers tt
  ON w.address = tt.to_address
JOIN web3.tokens t
  ON tt.token_id = t.token_id
GROUP BY w.wallet_id, w.address
HAVING COUNT(DISTINCT t.token_id) > 1
ORDER BY total_received_value DESC;

[User] Can you provide a summary of how many securities exist for each combination of exchange and sector?

[Assistant]
SELECT exchange, sector, COUNT(*) AS total_count
FROM financial_services.securities
GROUP BY exchange, sector;

[User] Please exclude any records where sector is NULL.

[Assistant]
SELECT exchange, sector, COUNT(*) AS total_count
FROM financial_services.securities
WHERE sector IS NOT NULL
GROUP BY exchange, sector;

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

[Assistant]
SELECT exchange, sector, COUNT(*) AS total_count
FROM financial_services.securities
WHERE sector IS NOT NULL
GROUP BY exchange, sector
ORDER BY total_count DESC;

[User] List the user ID, theme, and updated_at for users who have updated their settings in the last 90 days and have their theme set to 'dark'.

[Assistant] SELECT user_id, theme, updated_at FROM social_media.user_settings WHERE updated_at >= NOW() - INTERVAL '90 days' AND theme = 'dark';

[User] Refine the list to only show users who have also disabled push notifications.

[Assistant] SELECT user_id, theme, updated_at FROM social_media.user_settings WHERE updated_at >= NOW() - INTERVAL '90 days' AND theme = 'dark' AND push_notifications_enabled = FALSE;


System:
You are an 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 character varying(64) NOT NULL, -- unique identifier for the service
    agency_id character varying(64) NOT NULL, -- FK to agencies table
    service_name character varying(255) NOT NULL, -- name of the service (e.g., Driver's License Renewal)
    description text,
    category character varying(100), -- e.g., Licensing, Benefits, Taxation, Permits
    eligibility_criteria text, -- description of who is eligible
    standard_fee numeric(10, 2) DEFAULT 0.00, -- typical fee for the service
    average_processing_time_days integer, -- estimated processing time
    is_active boolean DEFAULT true, -- whether the service is currently offered
    online_application_url character varying(255),
    PRIMARY KEY (service_id)
)
CREATE TABLE government_services.service_locations (
    location_id character varying(64) NOT NULL, -- unique identifier for the physical location
    agency_id character varying(64) NOT NULL, -- FK to agencies table
    location_name character varying(200), -- e.g., Downtown DMV Office
    address text NOT NULL,
    city character varying(100),
    state character varying(50),
    postal_code character varying(20),
    latitude numeric(9, 6),
    longitude numeric(9, 6),
    operating_hours text, -- description of opening times
    contact_phone character varying(32),
    is_accessible boolean, -- accessibility information (e.g., wheelchair access)
    PRIMARY KEY (location_id)
)
CREATE TABLE government_services.appointments (
    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment
    citizen_id character varying(64) NOT NULL, -- FK to citizens table
    employee_id character varying(64), -- FK to employees table (optional, if assigned)
    location_id character varying(64), -- FK to service_locations table (if physical)
    service_id character varying(64), -- FK to services table (optional, if related to specific service)
    scheduled_start_time timestamp NOT NULL,
    scheduled_end_time timestamp,
    purpose text NOT NULL, -- reason for the appointment
    status character varying(30) NOT NULL, -- e.g., Scheduled, Completed, Cancelled, No-Show
    booking_method character varying(50), -- e.g., Online, Phone, In-Person
    created_at timestamp NOT NULL, -- when the appointment was booked
    notes text,
    PRIMARY KEY (appointment_id)
)
##Table Structure
CREATE TABLE healthcare.insurance_plans ( plan_id.text, plan_name.text, insurance_provider.text, plan_type.text, contact_phone.text, website.text )
##Table Structure
CREATE TABLE healthcare.medications ( medication_id text PRIMARY KEY, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )
##Table Structure
CREATE TABLE hospitality_technology.reservations ( reservation_id text PRIMARY KEY, property_id text, guest_id text, room_id text, room_type_id text, check_in_date date, check_out_date date, actual_check_in_ts timestamp, actual_check_out_ts timestamp, num_adults int, num_children int, status text, booking_source text, rate_plan_id text, total_amount numeric, amount_paid numeric, special_requests text, created_at timestamp, updated_at timestamp )
##Table Structure
CREATE TABLE transportation.trips ( trip_id text PRIMARY KEY, route_id text, vehicle_id text, driver_id text, scheduled_departure timestamp, actual_departure timestamp, scheduled_arrival timestamp, actual_arrival timestamp, origin_location_id text, destination_location_id text, status text, passenger_count int, cargo_manifest_id text )
##Table Structure
CREATE TABLE web3.contracts ( contract_id text, address text, abi text, bytecode text, deployer_address text, deployed_at timestamp, network_id text, status text )
CREATE TABLE web3.events ( event_id text, contract_id text, event_name text, data text, emitted_at timestamp, transaction_id text, log_index integer )
CREATE TABLE web3.transactions ( transaction_id text, from_address text, to_address text, value numeric, gas_used integer, gas_price numeric, block_number integer, timestamp timestamp, input_data text, status text, nonce integer )
CREATE TABLE web3.tokens ( token_id text, contract_address text, token_name text, token_symbol text, decimals integer, total_supply numeric )
CREATE TABLE web3.token_transfers ( transfer_id text, token_id text, from_address text, to_address text, value numeric, transaction_id text, log_index integer )
CREATE TABLE web3.users ( user_id text, username text, email text, password_hash text, created_at timestamp )
##Table Structure
CREATE TABLE healthcare.insurance_plans ( plan_id character varying(64) NOT NULL, plan_name character varying(200) NOT NULL, insurance_provider character varying(100) NOT NULL, plan_type character varying(50), contact_phone character varying(20), website character varying(255), PRIMARY KEY (plan_id) )

[User] Find the names of service locations where services categorized as 'Licensing' have had appointments scheduled.

[Assistant] SELECT DISTINCT T1.location_name FROM service_locations AS T1 JOIN appointments AS T2 ON T1.location_id = T2.location_id JOIN services AS T3 ON T2.service_id = T3.service_id WHERE T3.category = 'Licensing';

[User] I want to find all pairs of insurance plans that share the same contact phone number, showing plan IDs, names, and the shared phone.

[Assistant]
SELECT p1.plan_id, p1.plan_name, p2.plan_id AS plan_id_2, p2.plan_name AS plan_name_2, p1.contact_phone
FROM healthcare.insurance_plans p1
JOIN healthcare.insurance_plans p2
  ON p1.contact_phone = p2.contact_phone
  AND p1.plan_id < p2.plan_id;

[User] Actually, exclude any plans where the contact phone is null or empty.

[Assistant]
SELECT p1.plan_id, p1.plan_name, p2.plan_id AS plan_id_2, p2.plan_name AS plan_name_2, p1.contact_phone
FROM healthcare.insurance_plans p1
JOIN healthcare.insurance_plans p2
  ON p1.contact_phone = p2.contact_phone
  AND p1.plan_id < p2.plan_id
WHERE p1.contact_phone IS NOT NULL
  AND p1.contact_phone <> '';

[User] Find all medications whose NDC code starts with '0003'. Show the medication ID and NDC code.

[Assistant] SELECT medication_id, ndc_code FROM healthcare.medications WHERE ndc_code LIKE '0003%';

[User] Count the number of medications for each manufacturer and show manufacturers with more than 100 medications.

[Assistant] SELECT manufacturer, COUNT(*) AS medication_count FROM healthcare.medications GROUP BY manufacturer HAVING COUNT(*) > 100;

[User] Give me the total number of reservations and the sum of total_amount by month for the year 2023.

[Assistant]
SELECT DATE_TRUNC('month', check_in_date) AS month,
       COUNT(*)                         AS reservation_count,
       SUM(total_amount)               AS total_revenue
FROM hospitality_technology.reservations
WHERE EXTRACT(YEAR FROM check_in_date) = 2023
GROUP BY DATE_TRUNC('month', check_in_date)
ORDER BY month;

[User] Actually, I only want reservations with status 'CheckedOut' or 'Completed'.

[Assistant]
SELECT DATE_TRUNC('month', check_in_date) AS month,
       COUNT(*)                         AS reservation_count,
       SUM(total_amount)               AS total_revenue
FROM hospitality_technology.reservations
WHERE EXTRACT(YEAR FROM check_in_date) = 2023
  AND status IN ('CheckedOut', 'Completed')
GROUP BY DATE_TRUNC('month', check_in_date)
ORDER BY month;

[User] List all trips where the origin location is different from the destination location and show the trip ID, origin location ID, destination location ID, and route ID.

[Assistant] SELECT trip_id, origin_location_id, destination_location_id, route_id FROM transportation.trips WHERE origin_location_id <> destination_location_id;

[User] Show all token transfers where the token was created by a contract with status 'active'. Include transfer ID, token symbol, value, and the contract address.

[Assistant]
SELECT tt.transfer_id, tk.token_symbol, tt.value, tk.contract_address
FROM web3.token_transfers tt
JOIN web3.tokens tk ON tt.token_id = tk.token_id
JOIN web3.contracts c ON tk.contract_address = c.address
WHERE c.status = 'active'
ORDER BY tt.transfer_id;

[User] List the plan ID, plan name, and insurance provider for all plans whose plan type is 'EPO' and have a contact phone number specified.

[Assistant] SELECT plan_id, plan_name, insurance_provider FROM healthcare.insurance_plans WHERE plan_type = 'EPO' AND contact_phone IS NOT NULL;


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 )
##Table Structure
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.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 )
##Table Structure
CREATE TABLE transportation.trips (
    trip_id character varying(64) NOT NULL,  -- unique identifier for a specific trip instance
    route_id character varying(64), -- identifier of the route being followed (can be null for ad-hoc trips)
    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle used
    driver_id character varying(64) NOT NULL, -- identifier of the driver operating
    scheduled_departure timestamp with time zone NOT NULL, -- planned departure time
    actual_departure timestamp with time zone, -- actual departure time
    scheduled_arrival timestamp with time zone NOT NULL, -- planned arrival time
    actual_arrival timestamp with time zone, -- actual arrival time
    origin_location_id character varying(64) NOT NULL, -- actual starting location (could differ from route origin)
    destination_location_id character varying(64) NOT NULL, -- actual ending location (could differ from route destination)
    status character varying(32) NOT NULL, -- e.g., Scheduled, In Progress, Completed, Delayed, Cancelled
    passenger_count integer, -- number of passengers (if applicable)
    cargo_manifest_id character varying(64), -- link to cargo details (if applicable)
    PRIMARY KEY (trip_id)
)
##Table Structure
CREATE TABLE transportation.fuel_logs (
    fuel_log_id character varying(64) NOT NULL,  -- unique identifier for the fuel log entry
    vehicle_id character varying(64) NOT NULL, -- identifier of the vehicle fueled
    trip_id character varying(64), -- optional: identifier of the trip during which fueling occurred
    log_timestamp timestamp with time zone NOT NULL, -- time when fueling occurred
    fuel_type character varying(32) NOT NULL, -- type of fuel added (matches vehicle's fuel type)
    quantity numeric(10, 3) NOT NULL, -- amount of fuel added (e.g., Liters, Gallons, kWh)
    unit character varying(16) NOT NULL, -- unit of quantity (e.g., L, gal, kWh)
    cost_per_unit numeric(8, 4), -- price per unit of fuel
    total_cost numeric(10, 2) NOT NULL, -- total cost of the fuel purchase
    odometer_reading integer, -- vehicle mileage at time of fueling
    location_id character varying(64), -- identifier of the fueling station/location
    PRIMARY KEY (fuel_log_id)
)
##Table Structure
CREATE TABLE legal_services.clients ( client_id text, first_name text, last_name text, company_name text, email text, phone text, address text, date_registered timestamp, status text )
CREATE TABLE legal_services.time_entries ( entry_id character varying(64) NOT NULL, case_id character varying(64) NOT NULL, lawyer_id character varying(64) NOT NULL, date_worked date NOT NULL, hours_spent numeric(5, 2) NOT NULL CHECK (hours_spent > 0), billing_rate numeric(10, 2) NOT NULL, description text NOT NULL, is_billable boolean DEFAULT true, is_billed boolean DEFAULT false, invoice_id character varying(64), created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (entry_id) )
##Table Structure
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 )

[User] Find the total amount of payments and the number of payments for each status.

[Assistant]
SELECT status, SUM(amount) AS total_amount, COUNT(*) AS payment_count
FROM hospitality_technology.payments
GROUP BY status;

[User] Actually, could you also include the breakdown by payment method within each status?

[Assistant]
SELECT status, payment_method, SUM(amount) AS total_amount, COUNT(*) AS payment_count
FROM hospitality_technology.payments
GROUP BY status, payment_method;

[User] List all agents who have sold at least one policy for an insurance product of type 'Health'. For each agent, show their full name, agency name, and the product name.

[Assistant]
SELECT DISTINCT a.first_name || ' ' || a.last_name AS agent_full_name, a.agency_name, ip.product_name
FROM insurance.agents a
JOIN insurance.policies p ON a.agent_id = p.agent_id
JOIN insurance.insurance_products ip ON p.product_id = ip.product_id
WHERE ip.product_type = 'Health';

[User] List all trips that were completed and experienced a significant delay in actual arrival compared to the scheduled arrival (more than 45 minutes).

[Assistant]
SELECT
  trip_id,
  vehicle_id,
  driver_id,
  scheduled_arrival,
  actual_arrival,
  (actual_arrival - scheduled_arrival) AS arrival_delay
FROM transportation.trips
WHERE
  status = 'Completed'
  AND actual_arrival IS NOT NULL
  AND actual_arrival > scheduled_arrival + INTERVAL '45 minutes';

[User] For those completed trips with significant arrival delays, provide a count of how many fall into different delay duration categories: '45-90 mins', '>90 mins'.

[Assistant]
SELECT
  CASE
    WHEN (actual_arrival - scheduled_arrival) > INTERVAL '45 minutes' AND (actual_arrival - scheduled_arrival) <= INTERVAL '90 minutes' THEN '45-90 mins'
    WHEN (actual_arrival - scheduled_arrival) > INTERVAL '90 minutes' THEN '>90 mins'
    ELSE 'Other Delays' -- Should not be reached based on previous filter, but good practice
  END AS delay_category,
  COUNT(*)
FROM transportation.trips
WHERE
  status = 'Completed'
  AND actual_arrival IS NOT NULL
  AND actual_arrival > scheduled_arrival + INTERVAL '45 minutes'
GROUP BY
  delay_category;

[User] List consecutive fueling events for each vehicle where the refill quantity increased compared to the previous event. Include vehicle_id, previous timestamp and quantity, current timestamp and quantity.

[Assistant]
SELECT
  prev.vehicle_id,
  prev.log_timestamp AS previous_time,
  prev.quantity AS previous_quantity,
  curr.log_timestamp AS current_time,
  curr.quantity AS current_quantity
FROM (
  SELECT *, ROW_NUMBER() OVER (PARTITION BY vehicle_id ORDER BY log_timestamp) AS rn
  FROM transportation.fuel_logs
) prev
JOIN (
  SELECT *, ROW_NUMBER() OVER (PARTITION BY vehicle_id ORDER BY log_timestamp) AS rn
  FROM transportation.fuel_logs
) curr
  ON prev.vehicle_id = curr.vehicle_id
  AND curr.rn = prev.rn + 1
WHERE curr.quantity > prev.quantity;

[User] List the first and last names of clients whose client_id matches a lawyer_id in the time_entries table, along with the corresponding entry_id.

[Assistant] SELECT c.first_name, c.last_name, te.entry_id FROM legal_services.clients c JOIN legal_services.time_entries te ON c.client_id = te.lawyer_id;

[User] List each staff member who delivered orders, along with the number of orders they delivered.

[Assistant] SELECT staff_id_delivered, COUNT(order_id) AS delivered_orders FROM hospitality_technology.service_orders WHERE staff_id_delivered IS NOT NULL GROUP BY staff_id_delivered;

[User] Only show staff who delivered more than 10 orders.

[Assistant] SELECT staff_id_delivered, COUNT(order_id) AS delivered_orders FROM hospitality_technology.service_orders WHERE staff_id_delivered IS NOT NULL GROUP BY staff_id_delivered HAVING COUNT(order_id) > 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.documents ( document_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, document_type character varying(100) NOT NULL, file_reference text NOT NULL, upload_timestamp timestamp NOT NULL, expiry_date date, verification_status character varying(30) DEFAULT 'Pending', verified_by_employee_id character varying(64), verification_timestamp timestamp, PRIMARY KEY (document_id) )
CREATE TABLE government_services.payments ( payment_id character varying(64) NOT NULL, application_id character varying(64), citizen_id character varying(64) NOT NULL, service_id character varying(64), amount numeric(12, 2) NOT NULL, currency character varying(3) NOT NULL DEFAULT 'USD', payment_method character varying(50), payment_provider_reference character varying(128), payment_timestamp timestamp NOT NULL, status character varying(30) NOT NULL, notes text, PRIMARY KEY (payment_id) )
##Table Structure
CREATE TABLE healthcare.medical_records (
    record_id character varying(64) NOT NULL,  -- unique identifier for the medical record entry
    patient_id character varying(64) NOT NULL, -- FK to patients table
    appointment_id character varying(64) UNIQUE, -- FK to appointments table (can be null if record not tied to specific appt)
    doctor_id character varying(64) NOT NULL, -- FK to doctors table (doctor creating the record)
    record_date timestamp with time zone NOT NULL, -- date the record/observation was made
    chief_complaint text, -- patient's primary reason for visit
    present_illness_history text, -- detailed history of the current issue
    past_medical_history text, -- relevant past conditions/surgeries
    physical_examination_notes text, -- findings from the physical exam
    assessment text, -- doctor's assessment/diagnosis summary
    treatment_plan text, -- planned course of action
    vitals jsonb, -- store vitals like BP, HR, Temp as structured JSON
    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
    PRIMARY KEY (record_id)
)
CREATE TABLE healthcare.insurance_plans ( plan_id text, plan_name text, insurance_provider text, plan_type text, contact_phone text, website text )
##Table Structure
CREATE TABLE healthcare.prescriptions ( prescription_id.text, record_id.text, patient_id.text, doctor_id.text, medication_id.text, dosage.text, frequency.text, route.text, start_date.date, end_date.date, quantity_dispensed.numeric, refills_allowed.integer, prescription_date.timestamp )
##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.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.medications ( medication_id character varying(64) NOT NULL, medication_name character varying(255) NOT NULL, generic_name character varying(255), manufacturer character varying(100), ndc_code character varying(20) UNIQUE, description text, PRIMARY KEY (medication_id) )
CREATE TABLE healthcare.prescriptions ( prescription_id character varying(64) NOT NULL, record_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, medication_id character varying(64) NOT NULL, dosage character varying(100) NOT NULL, frequency character varying(100) NOT NULL, route character varying(50), start_date date NOT NULL, end_date date, quantity_dispensed numeric(10,2), refills_allowed integer NOT NULL DEFAULT 0, prescription_date timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (prescription_id) )

[User] List application IDs that have both documents and payments associated with them.

[Assistant] SELECT DISTINCT T1.application_id FROM documents AS T1 JOIN payments AS T2 ON T1.application_id = T2.application_id

[User] For those applications, also show the total payment amount.

[Assistant] SELECT T1.application_id, SUM(T2.amount) FROM documents AS T1 JOIN payments AS T2 ON T1.application_id = T2.application_id GROUP BY T1.application_id

[User] Can you provide a list of all medical records created by doctors for patients who are associated with 'PPO' type insurance plans? I need the record ID, patient ID, doctor ID, record date, and insurance plan name.

[Assistant]
SELECT mr.record_id, mr.patient_id, mr.doctor_id, mr.record_date, ip.plan_name
FROM healthcare.medical_records mr
JOIN healthcare.insurance_plans ip ON mr.patient_id IS NOT NULL -- placeholder JOIN, fix below if you have a patient-insurance mapping table
WHERE ip.plan_type = 'PPO';

[User] The SQL seems off because there's no direct mapping between patients and insurance_plans in the schema. Can you adjust the query so that it only lists medical records with the plan details if the doctor creating the record has a contact phone number that matches the plan's contact_phone? Still need the same output columns.

[Assistant]
SELECT mr.record_id, mr.patient_id, mr.doctor_id, mr.record_date, ip.plan_name
FROM healthcare.medical_records mr
JOIN healthcare.insurance_plans ip ON mr.doctor_id IS NOT NULL -- placeholder JOIN, fix below if you have a doctors table with contact_phone
WHERE ip.plan_type = 'PPO' AND ip.contact_phone IS NOT NULL;

[User] Actually, please sort the results by record_date in descending order and return only the latest 20 records.

[Assistant]
SELECT mr.record_id, mr.patient_id, mr.doctor_id, mr.record_date, ip.plan_name
FROM healthcare.medical_records mr
JOIN healthcare.insurance_plans ip ON mr.doctor_id IS NOT NULL -- placeholder JOIN, fix below if you have a doctors table with contact_phone
WHERE ip.plan_type = 'PPO' AND ip.contact_phone IS NOT NULL
ORDER BY mr.record_date DESC
LIMIT 20;

[User] For each prescription, find the next prescription for the same patient. Return current prescription_id, next_prescription_id, patient_id, and days between start dates.

[Assistant]
SELECT p1.patient_id,
       p1.prescription_id AS current_id,
       p2.prescription_id AS next_id,
       (p2.start_date - p1.start_date) AS days_between
FROM healthcare.prescriptions p1
JOIN healthcare.prescriptions p2
  ON p1.patient_id = p2.patient_id
 AND p2.start_date = (
       SELECT MIN(start_date)
       FROM healthcare.prescriptions p3
       WHERE p3.patient_id = p1.patient_id
         AND p3.start_date > p1.start_date
   );

[User] Only include pairs where days_between is less than 30 days.

[Assistant]
SELECT p1.patient_id,
       p1.prescription_id AS current_id,
       p2.prescription_id AS next_id,
       (p2.start_date - p1.start_date) AS days_between
FROM healthcare.prescriptions p1
JOIN healthcare.prescriptions p2
  ON p1.patient_id = p2.patient_id
 AND p2.start_date = (
       SELECT MIN(start_date)
       FROM healthcare.prescriptions p3
       WHERE p3.patient_id = p1.patient_id
         AND p3.start_date > p1.start_date
   )
WHERE (p2.start_date - p1.start_date) < 30;

[User] Can you list medical records along with the full name of the patient and their age at the time the record was created? Include record ID, record date, patient full name, and age in years.

[Assistant] SELECT mr.record_id, mr.record_date, p.first_name, p.last_name, date_part('year', age(mr.record_date, p.date_of_birth)) AS age_at_record FROM healthcare.medical_records mr JOIN healthcare.patients p ON mr.patient_id = p.patient_id;

[User] Please refine the results to only show records for patients who are currently between 30 and 50 years old and sort by record date in descending order.

[Assistant] SELECT mr.record_id, mr.record_date, p.first_name, p.last_name, date_part('year', age(mr.record_date, p.date_of_birth)) AS age_at_record FROM healthcare.medical_records mr JOIN healthcare.patients p ON mr.patient_id = p.patient_id WHERE date_part('year', age(p.date_of_birth)) BETWEEN 30 AND 50 ORDER BY mr.record_date DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement. ##Table Structure
CREATE TABLE web3.contracts ( contract_id character varying(64) NOT NULL, address character varying(128) NOT NULL, abi text NOT NULL, bytecode text NOT NULL, deployer_address character varying(128) NOT NULL, deployed_at timestamp NOT NULL, network_id character varying(64) NOT NULL, status character varying(32) NOT NULL, PRIMARY KEY (contract_id) )
CREATE TABLE web3.transactions ( transaction_id character varying(64) NOT NULL, from_address character varying(128) NOT NULL, to_address character varying(128), value numeric(38,14) NOT NULL, gas_used integer NOT NULL, gas_price numeric(38,14) NOT NULL, block_number integer NOT NULL, timestamp timestamp NOT NULL, input_data text, status character varying(32) NOT NULL, nonce integer NOT NULL, PRIMARY KEY (transaction_id) )
CREATE TABLE web3.tokens ( token_id.text, contract_address.text, token_name.text, token_symbol.text, decimals.integer, total_supply.numeric )
CREATE TABLE web3.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )
CREATE TABLE web3.users ( user_id text PRIMARY KEY, username text, email text, password_hash text, created_at timestamp )
##Table Structure
CREATE TABLE legal_services.lawyers ( lawyer_id text, first_name text, last_name text, bar_number text, firm_id text, email text, phone text, specialization text, hire_date timestamp, is_partner boolean )
CREATE TABLE legal_services.documents ( document_id text, case_id text, document_name text, document_type text, storage_path text, uploaded_by_lawyer_id text, upload_timestamp timestamp, version integer, description text )
##Table Structure
CREATE TABLE government_services.citizens (
    citizen_id character varying(64) NOT NULL,  -- unique identifier for the citizen
    national_id_number character varying(128) NOT NULL UNIQUE, -- official national identification number
    first_name character varying(100) NOT NULL,
    last_name character varying(100) NOT NULL,
    date_of_birth date NOT NULL,
    gender character varying(20),
    primary_address text NOT NULL, -- full primary residential address
    contact_email character varying(128) UNIQUE,
    contact_phone character varying(32),
    registration_date timestamp NOT NULL, -- when the citizen profile was created
    is_verified boolean DEFAULT false, -- whether identity has been officially verified
    PRIMARY KEY (citizen_id)
)
##Table Structure
CREATE TABLE web3.contracts ( contract_id.text, address.text, abi.text, bytecode.text, deployer_address.text, deployed_at.timestamp, network_id.text, status.text )
CREATE TABLE web3.events (
    event_id character varying(64) NOT NULL,  -- unique identifier for the event
    contract_id character varying(64) NOT NULL, -- identifier of the contract emitting the event
    event_name character varying(128) NOT NULL, -- name of the event
    data text NOT NULL, -- data payload of the event
    emitted_at timestamp NOT NULL, -- time when the event was emitted
    transaction_id character varying(64) NOT NULL, -- identifier of the transaction that triggered the event
    log_index integer NOT NULL, -- index of the event log in the transaction
    PRIMARY KEY (event_id)
)
CREATE TABLE web3.tokens ( token_id text PRIMARY KEY, contract_address text, token_name text, token_symbol text, decimals int, total_supply numeric )
CREATE TABLE web3.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )
CREATE TABLE web3.users ( user_id text, username text, email text, password_hash text, created_at timestamp )
##Table Structure
CREATE TABLE web3.contracts ( contract_id character varying(64) NOT NULL, address character varying(128) NOT NULL, abi text NOT NULL, bytecode text NOT NULL, deployer_address character varying(128) NOT NULL, deployed_at timestamp NOT NULL, network_id character varying(64) NOT NULL, status character varying(32) NOT NULL, PRIMARY KEY (contract_id) )
CREATE TABLE web3.events ( event_id.text, contract_id.text, event_name.text, data.text, emitted_at.timestamp, transaction_id.text, log_index.integer )
CREATE TABLE web3.tokens (
    token_id character varying(64) NOT NULL,  -- unique identifier for the token
    contract_address character varying(128) NOT NULL, -- address of the token contract
    token_name character varying(128) NOT NULL, -- name of the token
    token_symbol character varying(32) NOT NULL, -- symbol of the token
    decimals integer NOT NULL, -- number of decimals for the token
    total_supply numeric(38,14) NOT NULL, -- total supply of the token
    PRIMARY KEY (token_id)
)
CREATE TABLE web3.token_transfers ( transfer_id text PRIMARY KEY, token_id text, from_address text, to_address text, value numeric, transaction_id text, log_index int )
CREATE TABLE web3.users ( user_id text, username text, email text, password_hash text, created_at timestamp )
##Table Structure
CREATE TABLE web3.token_transfers ( transfer_id character varying(64) NOT NULL, token_id character varying(64) NOT NULL, from_address character varying(128) NOT NULL, to_address character varying(128) NOT NULL, value numeric(38,14) NOT NULL, transaction_id character varying(64) NOT NULL, log_index integer NOT NULL, PRIMARY KEY (transfer_id) )

[User] Show each token's symbol, token_name, and the deployer_address and status of the contract where that token was created.

[Assistant]
SELECT t.token_symbol,
       t.token_name,
       c.deployer_address,
       c.status
FROM web3.tokens t
JOIN web3.contracts c ON t.contract_address = c.address;

[User] Retrieve document names and the uploader's full name for all documents with version greater than 1.

[Assistant]
SELECT d.document_name,
       l.first_name || ' ' || l.last_name AS uploader
FROM legal_services.documents d
JOIN legal_services.lawyers l
  ON d.uploaded_by_lawyer_id = l.lawyer_id
WHERE d.version > 1;

[User] Also include the lawyer's specialization in the output.

[Assistant]
SELECT d.document_name,
       l.first_name || ' ' || l.last_name AS uploader,
       l.specialization
FROM legal_services.documents d
JOIN legal_services.lawyers l
  ON d.uploaded_by_lawyer_id = l.lawyer_id
WHERE d.version > 1;

[User] List pairs of verified citizens who share the same primary address city. Show the city, the full name of the first citizen, and the full name of the second citizen.

[Assistant] SELECT SPLIT_PART(c1.primary_address, ', ', 2) AS city, c1.first_name || ' ' || c1.last_name AS citizen1_full_name, c2.first_name || ' ' || c2.last_name AS citizen2_full_name FROM government_services.citizens AS c1 JOIN government_services.citizens AS c2 ON SPLIT_PART(c1.primary_address, ', ', 2) = SPLIT_PART(c2.primary_address, ', ', 2) AND c1.citizen_id < c2.citizen_id WHERE c1.is_verified = TRUE AND c2.is_verified = TRUE;

[User] List all users who created a wallet on the same day they registered. Show user ID, username, and the wallet address.

[Assistant] SELECT u.user_id, u.username, w.address FROM web3.users AS u JOIN web3.wallets AS w ON u.user_id = w.user_id WHERE DATE(u.created_at) = DATE(w.created_at);

[User] For each contract deployed on network 'mainnet', show its address, status, the number of tokens created by that contract's address, and the total number of events emitted by that contract.

[Assistant]
SELECT
  c.address AS contract_address,
  c.status,
  COUNT(DISTINCT t.token_id) AS token_count,
  COUNT(e.event_id) AS event_count
FROM web3.contracts c
LEFT JOIN web3.tokens t
  ON c.address = t.contract_address
LEFT JOIN web3.events e
  ON c.contract_id = e.contract_id
WHERE c.network_id = 'mainnet'
GROUP BY c.address, c.status;

[User] For each token, list the number of distinct sender addresses that have sent that token. Show the token ID and the count of distinct senders.

[Assistant] SELECT token_id, COUNT(DISTINCT from_address) AS distinct_sender_count FROM web3.token_transfers GROUP BY token_id;

[User] Can you filter the result to only show tokens that have more than 10 distinct sender addresses?

[Assistant] SELECT token_id, COUNT(DISTINCT from_address) AS distinct_sender_count FROM web3.token_transfers GROUP BY token_id HAVING COUNT(DISTINCT from_address) > 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 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 )
CREATE TABLE insurance.policies ( policy_id text, customer_id text, product_id text, agent_id text, policy_number text, start_date date, end_date date, premium_amount numeric, coverage_limit numeric, deductible numeric, status text, issued_at timestamp, cancellation_date date, cancellation_reason text )
CREATE TABLE insurance.claims ( claim_id text PRIMARY KEY, policy_id text, customer_id text, incident_date timestamp, reported_date timestamp, description text, estimated_loss numeric, status text, settlement_amount numeric, settlement_date date, claim_handler_id text, police_report_number text )
CREATE TABLE insurance.agents ( agent_id.text, first_name.text, last_name.text, agency_name.text, license_number.text, license_state.text, contact_email.text, contact_phone.text, hire_date.date, termination_date.date, status.text, commission_rate.numeric, manager_id.text )
CREATE TABLE insurance.premium_payments ( payment_id text, policy_id text, customer_id text, payment_date timestamp, amount_paid numeric, payment_method text, transaction_reference text, due_date date, payment_period_start date, payment_period_end date, status text )
CREATE TABLE insurance.claim_documents ( document_id text PRIMARY KEY, claim_id text, document_type text, file_name text, file_path text, file_size_bytes int, mime_type text, uploaded_by text, uploaded_at timestamp, description text )
CREATE TABLE insurance.policy_beneficiaries ( beneficiary_id text, policy_id text, customer_id text, first_name text, last_name text, relationship text, percentage_share numeric, contact_info text, added_at timestamp )
##Table Structure
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) )
##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)
)
CREATE TABLE web3.transactions ( transaction_id character varying(64) NOT NULL, from_address character varying(128) NOT NULL, to_address character varying(128), value numeric(38,14) NOT NULL, gas_used integer NOT NULL, gas_price numeric(38,14) NOT NULL, block_number integer NOT NULL, timestamp timestamp NOT NULL, input_data text, status character varying(32) NOT NULL, nonce integer NOT NULL, PRIMARY KEY (transaction_id) )
CREATE TABLE web3.tokens ( token_id text PRIMARY KEY, contract_address text, token_name text, token_symbol text, decimals int, total_supply numeric )
CREATE TABLE web3.token_transfers ( transfer_id text, token_id text, from_address text, to_address text, value numeric, transaction_id text, log_index integer )
CREATE TABLE web3.wallets ( wallet_id text PRIMARY KEY, user_id text, address text, private_key text, created_at timestamp )
##Table Structure
CREATE TABLE legal_services.cases (
    case_id character varying(64) NOT NULL,  -- unique identifier for the case/matter
    case_number character varying(100) UNIQUE, -- official case number (court or internal)
    case_name text NOT NULL, -- descriptive name or title for the case
    client_id character varying(64) NOT NULL, -- FK to clients table
    lead_lawyer_id character varying(64) NOT NULL, -- FK to lawyers table (primary lawyer responsible)
    case_type character varying(100) NOT NULL, -- e.g., Litigation, Corporate, Family Law, IP
    status character varying(50) NOT NULL, -- e.g., Open, Closed, Pending, On Hold, Appealed
    date_opened timestamp NOT NULL, -- date the case was formally opened
    date_closed timestamp, -- date the case was closed (nullable)
    description text, -- detailed description of the case
    court_jurisdiction character varying(128), -- court or jurisdiction if applicable
    PRIMARY KEY (case_id)
)
##Table Structure
CREATE TABLE gaming_technology.player_inventory ( inventory_id uuid NOT NULL DEFAULT gen_random_uuid(), player_id uuid NOT NULL, item_id uuid NOT NULL, quantity integer NOT NULL DEFAULT 1, acquired_at timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, instance_data jsonb, PRIMARY KEY (inventory_id) )

[User] What is the average commission rate for agents whose status is 'Terminated'?

[Assistant] SELECT AVG(commission_rate) FROM insurance.agents WHERE status = 'Terminated' AND commission_rate IS NOT NULL;

[User] Show me the top 5 smart money addresses by profit on the Ethereum chain, along with their most profitable token and ROI, but only include addresses with a realized profit ratio above 70%.

[Assistant] SELECT address, most_profit_token, roi FROM smart_money_profit WHERE chain = 'Ethereum' AND realized_ratio > 70 ORDER BY profit DESC LIMIT 5;

[User] Can you also include their rank and filter to only show addresses with ROI greater than 50%?

[Assistant] SELECT address, most_profit_token, roi, rank FROM smart_money_profit WHERE chain = 'Ethereum' AND realized_ratio > 70 AND roi > 50 ORDER BY profit DESC LIMIT 5;

[User] For each wallet, list its address, the user_id, and the total value of all token transfers sent from that wallet, along with the contract address of the token.

[Assistant]
SELECT w.wallet_id, w.address, w.user_id, SUM(tt.value) AS total_sent_value, t.contract_address
FROM web3.wallets w
LEFT JOIN web3.token_transfers tt ON w.address = tt.from_address
LEFT JOIN web3.tokens t ON tt.token_id = t.token_id
GROUP BY w.wallet_id, w.address, w.user_id, t.contract_address;

[User] Calculate the average number of days cases stay open before being closed, grouped by case type. Only consider cases that have a date closed.

[Assistant] SELECT case_type, AVG(DATE_PART('day', date_closed - date_opened)) AS average_duration_days FROM legal_services.cases WHERE status = 'Closed' AND date_closed IS NOT NULL GROUP BY case_type;

[User] Exclude case types where the average duration is less than 100 days and order the results by average duration descending.

[Assistant] SELECT case_type, AVG(DATE_PART('day', date_closed - date_opened)) AS average_duration_days FROM legal_services.cases WHERE status = 'Closed' AND date_closed IS NOT NULL GROUP BY case_type HAVING AVG(DATE_PART('day', date_closed - date_opened)) >= 100 ORDER BY average_duration_days DESC;

[User] Find players who own items with rarity 'Rare' or higher ('Epic', 'Legendary') and list their usernames.

[Assistant] SELECT DISTINCT T1.username FROM players AS T1 INNER JOIN player_inventory AS T2 ON T1.player_id = T2.player_id INNER JOIN items AS T3 ON T2.item_id = T3.item_id WHERE T3.rarity IN ('Rare', 'Epic', 'Legendary');

[User] Filter this list further to only include players who acquired these items after '2024-01-01'.

[Assistant] SELECT DISTINCT T1.username FROM players AS T1 INNER JOIN player_inventory AS T2 ON T1.player_id = T2.player_id INNER JOIN items AS T3 ON T2.item_id = T3.item_id WHERE T3.rarity IN ('Rare', 'Epic', 'Legendary') AND T2.acquired_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 transportation.drivers ( driver_id text PRIMARY KEY, employee_id text, first_name text, last_name text, license_number text, license_expiry_date date, contact_number text, email text, hire_date date, status text )
##Table Structure
CREATE TABLE legal_services.lawyers ( lawyer_id text, first_name text, last_name text, bar_number text, firm_id text, email text, phone text, specialization text, hire_date timestamp, is_partner boolean )
##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 )
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 )
##Table Structure
CREATE TABLE insurance.claims ( claim_id character varying(64) NOT NULL, policy_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, incident_date timestamp NOT NULL, reported_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, description text NOT NULL, estimated_loss numeric(15, 2), status character varying(30) NOT NULL, settlement_amount numeric(15, 2), settlement_date date, claim_handler_id character varying(64), police_report_number character varying(100), PRIMARY KEY (claim_id) )
CREATE TABLE insurance.claim_documents ( document_id.text, claim_id.text, document_type.text, file_name.text, file_path.text, file_size_bytes.integer, mime_type.text, uploaded_by.text, uploaded_at.timestamp, description.text )
##Table Structure
CREATE TABLE social_media.messages ( message_id character varying(64) NOT NULL, conversation_id character varying(64) NOT NULL, sender_user_id character varying(64) NOT NULL, content text, media_url text, media_type character varying(20), sent_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, read_at timestamp, PRIMARY KEY (message_id) )
CREATE TABLE social_media.conversation_participants ( participant_id character varying(64) NOT NULL, conversation_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, joined_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, last_read_at timestamp, PRIMARY KEY (participant_id), CONSTRAINT unique_user_conversation UNIQUE (conversation_id, user_id) )
##Table Structure
CREATE TABLE legal_services.clients ( client_id text, first_name text, last_name text, company_name text, email text, phone text, address text, date_registered timestamp, status text )
CREATE TABLE legal_services.law_firms ( firm_id text, firm_name text, address text, phone text, website text, founded_date date, managing_partner_id text )
CREATE TABLE legal_services.cases ( case_id text, case_number text, case_name text, client_id text, lead_lawyer_id text, case_type text, status text, date_opened timestamp, date_closed timestamp, description text, court_jurisdiction text )
CREATE TABLE legal_services.documents ( document_id text, case_id text, document_name text, document_type text, storage_path text, uploaded_by_lawyer_id text, upload_timestamp timestamp, version integer, description text )
CREATE TABLE legal_services.time_entries ( entry_id text, case_id text, lawyer_id text, date_worked date, hours_spent numeric, billing_rate numeric, description text, is_billable boolean, is_billed boolean, invoice_id text, created_at timestamp )
##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) )
##Table Structure
CREATE TABLE financial_services.loans ( loan_id text, account_id text, loan_type text, principal_amount numeric, current_principal_balance numeric, interest_rate numeric, term_months integer, origination_date date, maturity_date date, monthly_payment numeric, collateral_description text, status text )

[User] Retrieve the driver_id, first_name, and last_name for all drivers whose license_expiry_date falls within the next 6 months from today.

[Assistant]
SELECT driver_id, first_name, last_name
FROM transportation.drivers
WHERE license_expiry_date BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '6 months';

[User] Now, also include those drivers' email addresses and sort the results by license_expiry_date ascending.

[Assistant]
SELECT driver_id, first_name, last_name, email
FROM transportation.drivers
WHERE license_expiry_date BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '6 months'
ORDER BY license_expiry_date ASC;

[User] List each partner’s full name along with the full name of a non-partner lawyer in the same firm.

[Assistant]
SELECT p.lawyer_id,
       CONCAT(p.first_name, ' ', p.last_name) AS partner_full_name,
       CONCAT(n.first_name, ' ', n.last_name) AS non_partner_full_name
FROM legal_services.lawyers p
JOIN legal_services.lawyers n
  ON p.firm_id = n.firm_id
  AND p.lawyer_id <> n.lawyer_id
WHERE p.is_partner = TRUE
  AND n.is_partner = FALSE;

[User] Only include non-partner lawyers hired after 2023-01-01.

[Assistant]
SELECT p.lawyer_id,
       CONCAT(p.first_name, ' ', p.last_name) AS partner_full_name,
       CONCAT(n.first_name, ' ', n.last_name) AS non_partner_full_name
FROM legal_services.lawyers p
JOIN legal_services.lawyers n
  ON p.firm_id = n.firm_id
  AND p.lawyer_id <> n.lawyer_id
WHERE p.is_partner = TRUE
  AND n.is_partner = FALSE
  AND n.hire_date > '2023-01-01';

[User] Show the service names that had documents uploaded for their applications in the calendar year 2023.

[Assistant] SELECT DISTINCT T1.service_name FROM government_services.services AS T1 JOIN applications AS T2 ON T1.service_id = T2.service_id JOIN government_services.documents AS T3 ON T2.application_id = T3.application_id WHERE EXTRACT(YEAR FROM T3.upload_timestamp) = 2023

[User] Only include services belonging to the 'Healthcare' category.

[Assistant] SELECT DISTINCT T1.service_name FROM government_services.services AS T1 JOIN applications AS T2 ON T1.service_id = T2.service_id JOIN government_services.documents AS T3 ON T2.application_id = T3.application_id WHERE EXTRACT(YEAR FROM T3.upload_timestamp) = 2023 AND T1.category = 'Healthcare'

[User] Find all documents that are larger than 5MB. Show the document ID, claim ID, file name, and file size in bytes.

[Assistant]
SELECT document_id, claim_id, file_name, file_size_bytes
FROM insurance.claim_documents
WHERE file_size_bytes > 5242880;

[User] What is the total number of messages sent with a media URL?

[Assistant] SELECT COUNT(*) FROM social_media.messages WHERE media_url IS NOT NULL;

[User] Which clients have at least one open case, and what are the names and numbers of those cases?

[Assistant]
SELECT c.first_name, c.last_name, cs.case_name, cs.case_number
FROM legal_services.clients c
JOIN legal_services.cases cs ON c.client_id = cs.client_id
WHERE cs.status = 'Open';

[User] Show the count of vehicles for each type.

[Assistant] SELECT type, COUNT(*) AS vehicle_count FROM transportation.vehicles GROUP BY type;

[User] Only include types where the vehicle count is greater than 2 and order the results by vehicle_count descending.

[Assistant] SELECT type, COUNT(*) AS vehicle_count FROM transportation.vehicles GROUP BY type HAVING COUNT(*) > 2 ORDER BY vehicle_count DESC;

[User] What is the average interest rate for auto loans (loan_type = 'Auto') with a principal amount between $20,000 and $50,000?

[Assistant] SELECT AVG(interest_rate) AS avg_interest_rate FROM financial_services.loans WHERE loan_type = 'Auto' AND principal_amount BETWEEN 20000 AND 50000;


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) )
##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.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.appointments ( appointment_id text, patient_id text, doctor_id text, appointment_time timestamp, duration_minutes integer, reason text, status text, location_id text, notes text, created_at timestamp )
CREATE TABLE healthcare.medical_records ( record_id text, patient_id text, appointment_id text, doctor_id text, record_date timestamp, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals text, created_at timestamp )
CREATE TABLE healthcare.medications ( medication_id text, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )
CREATE TABLE healthcare.insurance_plans ( plan_id text, plan_name text, insurance_provider text, plan_type text, contact_phone text, website text )
CREATE TABLE healthcare.patient_insurance ( patient_insurance_id text, patient_id text, plan_id text, policy_number text, group_number text, subscriber_name text, effective_date date, expiration_date date, is_primary boolean )
##Table Structure
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.notifications ( notification_id text, recipient_user_id text, sender_user_id text, notification_type text, target_entity_id text, target_entity_type text, created_at timestamp, read_at timestamp )
##Table Structure
CREATE TABLE healthcare.prescriptions ( prescription_id text PRIMARY KEY, record_id text, patient_id text, doctor_id text, medication_id text, dosage text, frequency text, route text, start_date date, end_date date, quantity_dispensed numeric, refills_allowed int, prescription_date timestamp )
##Table Structure
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.post_hashtags ( post_hashtag_id character varying(64) NOT NULL, post_id character varying(64) NOT NULL, hashtag_id character varying(64) NOT NULL, PRIMARY KEY (post_hashtag_id), CONSTRAINT unique_post_hashtag UNIQUE (post_id, hashtag_id) )
CREATE TABLE social_media.messages ( message_id text, conversation_id text, sender_user_id text, content text, media_url text, media_type text, sent_at timestamp, read_at timestamp )
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.notifications ( notification_id text PRIMARY KEY, recipient_user_id text, sender_user_id text, notification_type text, target_entity_id text, target_entity_type text, created_at timestamp, read_at timestamp )
##Table Structure
CREATE TABLE insurance.claims (
    claim_id character varying(64) NOT NULL, -- unique identifier for the claim
    policy_id character varying(64) NOT NULL, -- identifier of the policy under which the claim is made (FK to policies)
    customer_id character varying(64) NOT NULL, -- identifier of the customer making the claim (FK to customers)
    incident_date timestamp NOT NULL, -- date and time of the incident leading to the claim
    reported_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the claim was reported
    description text NOT NULL, -- detailed description of the incident and claim
    estimated_loss numeric(15, 2), -- initial estimated cost of the loss
    status character varying(30) NOT NULL, -- e.g., Filed, Processing, Under Review, Approved, Denied, Settled
    settlement_amount numeric(15, 2), -- final amount paid out
    settlement_date date,
    claim_handler_id character varying(64), -- identifier for the employee handling the claim (FK to employees/adjusters)
    police_report_number character varying(100),
    PRIMARY KEY (claim_id)
)
##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] Find all law firms that share the same address, listing each address and the two firm names.

[Assistant] SELECT f1.address, f1.firm_name AS firm1, f2.firm_name AS firm2 FROM law_firms f1 JOIN law_firms f2 ON f1.address = f2.address AND f1.firm_id < f2.firm_id;

[User] Actually, only show addresses containing the word 'Street'.

[Assistant] SELECT f1.address, f1.firm_name AS firm1, f2.firm_name AS firm2 FROM law_firms f1 JOIN law_firms f2 ON f1.address = f2.address AND f1.firm_id < f2.firm_id WHERE f1.address LIKE '%Street%';

[User] Count the number of medications for each unique generic name. Show the generic name and the count.

[Assistant]
SELECT
  generic_name,
  COUNT(medication_id) AS medication_count
FROM healthcare.medications
WHERE
  generic_name IS NOT NULL
GROUP BY
  generic_name;

[User] Only show generic names that have more than 5 associated medications.

[Assistant]
SELECT
  generic_name,
  COUNT(medication_id) AS medication_count
FROM healthcare.medications
WHERE
  generic_name IS NOT NULL
GROUP BY
  generic_name
HAVING
  COUNT(medication_id) > 5;

[User] List all unread notifications for group conversations, including the conversation name, sender_user_id, and notification creation time.

[Assistant]
SELECT c.group_name, n.sender_user_id, n.created_at
FROM social_media.notifications n
JOIN social_media.conversations c
  ON n.target_entity_type = 'conversation'
  AND n.target_entity_id = c.conversation_id
WHERE c.is_group_chat = TRUE
  AND n.read_at IS NULL;

[User] Actually, show only those notifications created in the last 7 days.

[Assistant]
SELECT c.group_name, n.sender_user_id, n.created_at
FROM social_media.notifications n
JOIN social_media.conversations c
  ON n.target_entity_type = 'conversation'
  AND n.target_entity_id = c.conversation_id
WHERE c.is_group_chat = TRUE
  AND n.read_at IS NULL
  AND n.created_at >= now() - interval '7 days';

[User] Find pairs of prescriptions issued to the same patient but for different medications, issued on the same date. Show the patient ID, the prescription IDs of the two prescriptions, and their medication IDs and prescription dates.

[Assistant] SELECT p1.patient_id, p1.prescription_id AS prescription1_id, p1.medication_id AS medication1_id, p2.prescription_id AS prescription2_id, p2.medication_id AS medication2_id, p1.prescription_date FROM healthcare.prescriptions p1 JOIN healthcare.prescriptions p2 ON p1.patient_id = p2.patient_id AND p1.prescription_date = p2.prescription_date AND p1.medication_id <> p2.medication_id AND p1.prescription_id < p2.prescription_id;

[User] Show me the number of notifications sent by each sender in March 2024.

[Assistant]
SELECT sender_user_id, COUNT(notification_id) AS notification_count
FROM social_media.notifications
WHERE created_at >= '2024-03-01'::timestamp
  AND created_at < '2024-04-01'::timestamp
GROUP BY sender_user_id;

[User] What is the average estimated_loss for claims with status 'Filed' or 'Approved'?

[Assistant]
SELECT AVG(estimated_loss) AS avg_estimated_loss
FROM insurance.claims
WHERE status IN ('Filed', 'Approved');

[User] Count how many insurance plans exist for each plan type.

[Assistant]
SELECT plan_type, COUNT(*) AS plan_count
FROM healthcare.insurance_plans
GROUP BY plan_type;

[User] Now filter to only show plan types with more than 2 plans.

[Assistant]
SELECT plan_type, COUNT(*) AS plan_count
FROM healthcare.insurance_plans
GROUP BY plan_type
HAVING COUNT(*) > 2;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement. ##Table Structure
CREATE TABLE transportation.drivers ( driver_id.text, employee_id.text, first_name.text, last_name.text, license_number.text, license_expiry_date.date, contact_number.text, email.text, hire_date.date, status.text )
CREATE TABLE transportation.routes ( route_id.text, route_number.text, description.text, origin_location_id.text, destination_location_id.text, distance_km.numeric, estimated_duration_minutes.integer, type.text )
CREATE TABLE transportation.trips ( trip_id.text, route_id.text, vehicle_id.text, driver_id.text, scheduled_departure.timestamp, actual_departure.timestamp, scheduled_arrival.timestamp, actual_arrival.timestamp, origin_location_id.text, destination_location_id.text, status.text, passenger_count.integer, cargo_manifest_id.text )
CREATE TABLE transportation.locations ( location_id.text, name.text, type.text, address_line1.text, city.text, state_province.text, postal_code.text, country.text, latitude.numeric, longitude.numeric, timezone.text )
CREATE TABLE transportation.maintenance_logs ( log_id.text, vehicle_id.text, service_date.date, odometer_reading.integer, service_type.text, description.text, cost.numeric, mechanic_name.text, next_service_due_date.date )
CREATE TABLE transportation.fuel_logs ( fuel_log_id.text, vehicle_id.text, trip_id.text, log_timestamp.timestamp, fuel_type.text, quantity.numeric, unit.text, cost_per_unit.numeric, total_cost.numeric, odometer_reading.integer, location_id.text )
CREATE TABLE transportation.passengers ( passenger_id.text, first_name.text, last_name.text, email.text, phone_number.text, date_of_birth.date, loyalty_program_id.text, created_at.timestamp )
CREATE TABLE transportation.bookings ( booking_id.text, passenger_id.text, trip_id.text, seat_number.text, booking_time.timestamp, status.text, fare.numeric, payment_transaction_id.text, special_requests.text )
##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 )
##Table Structure
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) )
##Table Structure
CREATE TABLE trading_platform.users ( user_id text PRIMARY KEY, username text, email text, password_hash text, created_at timestamp )
CREATE TABLE trading_platform.wallets ( wallet_id text PRIMARY KEY, user_id text, address text, private_key text, created_at timestamp )
CREATE TABLE trading_platform.trades ( trade_id text PRIMARY KEY, order_id text, buyer_id text, seller_id text, asset_id text, quantity numeric, price numeric, traded_at timestamp )
CREATE TABLE trading_platform.assets ( asset_id text PRIMARY KEY, name text, symbol text, type text )
CREATE TABLE trading_platform.utxos ( utxo_id text PRIMARY KEY, transaction_id text, output_index int, address text, amount numeric, spent boolean )
CREATE TABLE trading_platform.dapps ( dapp_id text PRIMARY KEY, name text, description text, url text )
CREATE TABLE trading_platform.peers ( peer_id text PRIMARY KEY, ip_address text, port int, last_seen timestamp )
CREATE TABLE trading_platform.metadata ( metadata_id text PRIMARY KEY, asset_id text, key text, value text )
CREATE TABLE trading_platform.kyc_audit ( kyc_audit_id text PRIMARY KEY, user_id text, status text, reviewed_at timestamp )
CREATE TABLE trading_platform.logs ( log_id text PRIMARY KEY, user_id text, action text, details text, logged_at timestamp )
CREATE TABLE trading_platform.notifications ( notification_id text PRIMARY KEY, user_id text, message text, sent_at timestamp, read_at timestamp )
##Table Structure
CREATE TABLE social_media.conversation_participants ( participant_id.text, conversation_id.text, user_id.text, joined_at.timestamp, last_read_at.timestamp )
##Table Structure
CREATE TABLE social_media.messages ( message_id.text, conversation_id.text, sender_user_id.text, content.text, media_url.text, media_type.text, sent_at.timestamp, read_at.timestamp )
CREATE TABLE social_media.notifications ( notification_id text, recipient_user_id text, sender_user_id text, notification_type text, target_entity_id text, target_entity_type text, created_at timestamp, read_at timestamp )

[User] Could you list the route number and the name of the destination location for routes that start at a location of type 'Depot'?

[Assistant] SELECT T1.route_number ,  T2.name FROM transportation.routes AS T1 JOIN transportation.locations AS T2 ON T1.origin_location_id  =  T2.location_id WHERE T2.type  =  'Depot'

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

[Assistant] SELECT DISTINCT specialty FROM healthcare.doctors;

[User] How many distinct tokens did smart money buy on the 'BSC' chain in 2023?

[Assistant]
SELECT COUNT(DISTINCT token_address) AS distinct_tokens_bought
FROM smart_money_token_inflow
WHERE type = 1
  AND chain = 'BSC'
  AND to_char(cast(token_address AS text), 'YYYY-MM-DD') >= '2023-01-01'
  AND to_char(cast(token_address AS text), 'YYYY-MM-DD') <= '2023-12-31';

[User] Can you break this down by narrative and show the count per narrative?

[Assistant]
SELECT narrative, COUNT(DISTINCT token_address) AS distinct_tokens_bought
FROM smart_money_token_inflow
WHERE type = 1
  AND chain = 'BSC'
  AND to_char(cast(token_address AS text), 'YYYY-MM-DD') >= '2023-01-01'
  AND to_char(cast(token_address AS text), 'YYYY-MM-DD') <= '2023-12-31'
GROUP BY narrative
ORDER BY distinct_tokens_bought DESC;

[User] List all users who currently have a 'pending' KYC status, showing their user ID and username.

[Assistant] SELECT u.user_id, u.username FROM users u JOIN kyc_audit k ON u.user_id = k.user_id WHERE k.status = 'pending';

[User] Which users participated in more than one conversation? Show their user_id and participant_id for each conversation, along with the joined_at time.

[Assistant] SELECT user_id, participant_id, conversation_id, joined_at FROM social_media.conversation_participants WHERE user_id IN (SELECT user_id FROM social_media.conversation_participants GROUP BY user_id HAVING COUNT(DISTINCT conversation_id) > 1) ORDER BY user_id, joined_at;

[User] Can you also show the last_read_at time for each participant in the result?

[Assistant] SELECT user_id, participant_id, conversation_id, joined_at, last_read_at FROM social_media.conversation_participants WHERE user_id IN (SELECT user_id FROM social_media.conversation_participants GROUP BY user_id HAVING COUNT(DISTINCT conversation_id) > 1) ORDER BY user_id, joined_at;

[User] How many unread messages does each sender have? Show sender_user_id and count of messages where read_at is null.

[Assistant]
SELECT sender_user_id, COUNT(*) AS unread_messages
FROM social_media.messages
WHERE read_at IS NULL
GROUP BY sender_user_id;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement. ##Table Structure
CREATE TABLE 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.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 text, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )
CREATE TABLE healthcare.prescriptions ( prescription_id text, record_id text, patient_id text, doctor_id text, medication_id text, dosage text, frequency text, route text, start_date date, end_date date, quantity_dispensed numeric, refills_allowed integer, prescription_date timestamp )
CREATE TABLE healthcare.insurance_plans ( plan_id text, plan_name text, insurance_provider text, plan_type text, contact_phone text, website text )
CREATE TABLE healthcare.patient_insurance ( patient_insurance_id text, patient_id text, plan_id text, policy_number text, group_number text, subscriber_name text, effective_date date, expiration_date date, is_primary boolean )
##Table Structure
CREATE TABLE gaming_technology.developers ( developer_id uuid PRIMARY KEY, name text, country text, founded_year int, website text, created_at timestamptz )
##Table Structure
CREATE TABLE transportation.vehicles (
    vehicle_id character varying(64) NOT NULL,  -- unique identifier for the vehicle
    license_plate character varying(32) NOT NULL UNIQUE, -- vehicle license plate
    vin character varying(17) UNIQUE, -- vehicle identification number
    make character varying(64) NOT NULL, -- manufacturer of the vehicle
    model character varying(64) NOT NULL, -- model of the vehicle
    year integer NOT NULL, -- manufacturing year
    type character varying(32) NOT NULL, -- type of vehicle (e.g., Bus, Train, Truck, Car, Van)
    capacity integer, -- passenger or cargo capacity
    fuel_type character varying(32) NOT NULL, -- e.g., Diesel, Gasoline, Electric, Hydrogen
    status character varying(32) NOT NULL, -- e.g., Active, Maintenance, Decommissioned
    depot_id character varying(64), -- identifier of the home depot/base
    acquisition_date date, -- date the vehicle was acquired
    PRIMARY KEY (vehicle_id)
)
CREATE TABLE transportation.drivers ( driver_id.text, employee_id.text, first_name.text, last_name.text, license_number.text, license_expiry_date.date, contact_number.text, email.text, hire_date.date, status.text )
CREATE TABLE transportation.routes ( route_id.text, route_number.text, description.text, origin_location_id.text, destination_location_id.text, distance_km.numeric, estimated_duration_minutes.integer, type.text )
CREATE TABLE transportation.maintenance_logs ( log_id text PRIMARY KEY, vehicle_id text, service_date date, odometer_reading int, service_type text, description text, cost numeric, mechanic_name text, next_service_due_date date )
CREATE TABLE transportation.passengers ( passenger_id.text, first_name.text, last_name.text, email.text, phone_number.text, date_of_birth.date, loyalty_program_id.text, created_at.timestamp )
##Table Structure
CREATE TABLE legal_services.lawyers ( lawyer_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, bar_number character varying(64) UNIQUE NOT NULL, firm_id character varying(64), email character varying(128) UNIQUE NOT NULL, phone character varying(32), specialization text, hire_date timestamp NOT NULL, is_partner boolean DEFAULT false, PRIMARY KEY (lawyer_id) )
##Table Structure
CREATE TABLE financial_services.customers ( customer_id.text, first_name.text, last_name.text, date_of_birth.date, ssn_hash.text, address.text, city.text, state.text, zip_code.text, country.text, email.text, phone_number.text, created_at.timestamp, status.text, risk_profile.text )
##Table Structure
CREATE TABLE blockchain.addresses ( address_id.text, public_key.text, balance.numeric )
CREATE TABLE blockchain.wallets ( wallet_id text, user_id text, address_id text, private_key text )

[User] List each insurance provider with the count of primary active policies (is_primary = TRUE and expiration_date IS NULL or expiration_date > CURRENT_DATE). Return the provider and the count.

[Assistant]
SELECT ip.insurance_provider, COUNT(*) AS primary_policy_count
FROM healthcare.patient_insurance pi
JOIN healthcare.insurance_plans ip ON pi.plan_id = ip.plan_id
WHERE pi.is_primary = TRUE
  AND (pi.expiration_date IS NULL OR pi.expiration_date > CURRENT_DATE)
GROUP BY ip.insurance_provider;

[User] Find all pairs of developers in the same country but founded in different years. Show developer1, developer2, country, founded_year of each.

[Assistant]
SELECT d1.name AS developer1,
       d2.name AS developer2,
       d1.country,
       d1.founded_year AS founded1,
       d2.founded_year AS founded2
FROM gaming_technology.developers d1
JOIN gaming_technology.developers d2
  ON d1.country = d2.country
 AND d1.developer_id < d2.developer_id
 AND d1.founded_year <> d2.founded_year;

[User] Now only include pairs where the difference in founded_year is at least 15 years.

[Assistant]
SELECT d1.name AS developer1,
       d2.name AS developer2,
       d1.country,
       d1.founded_year AS founded1,
       d2.founded_year AS founded2
FROM gaming_technology.developers d1
JOIN gaming_technology.developers d2
  ON d1.country = d2.country
 AND d1.developer_id < d2.developer_id
 AND ABS(d1.founded_year - d2.founded_year) >= 15;

[User] List all maintenance logs for vehicles acquired in the year 2023. Include log ID, vehicle make, model, service date, and cost.

[Assistant] SELECT ml.log_id, v.make, v.model, ml.service_date, ml.cost FROM transportation.maintenance_logs AS ml JOIN transportation.vehicles AS v ON ml.vehicle_id = v.vehicle_id WHERE EXTRACT(YEAR FROM v.acquisition_date) = 2023;

[User] Find pairs of lawyers who work for the same firm AND share the same specialization, excluding pairs where the lawyer IDs are the same. Show their first names, last names, firm ID, and specialization. Order the results by firm ID and then specialization.

[Assistant] SELECT l1.first_name, l1.last_name, l2.first_name AS lawyer2_first_name, l2.last_name AS lawyer2_last_name, l1.firm_id, l1.specialization FROM legal_services.lawyers AS l1 JOIN legal_services.lawyers AS l2 ON l1.firm_id = l2.firm_id AND l1.specialization = l2.specialization AND l1.lawyer_id < l2.lawyer_id ORDER BY l1.firm_id, l1.specialization;

[User] Calculate the average age of customers grouped by risk_profile.

[Assistant]
SELECT risk_profile, AVG(EXTRACT(YEAR FROM AGE(current_date, date_of_birth)))::numeric(5,2) AS average_age, COUNT(*) AS customer_count
FROM financial_services.customers
GROUP BY risk_profile;

[User] Exclude risk profiles that have fewer than 50 customers.

[Assistant]
SELECT risk_profile, AVG(EXTRACT(YEAR FROM AGE(current_date, date_of_birth)))::numeric(5,2) AS average_age, COUNT(*) AS customer_count
FROM financial_services.customers
GROUP BY risk_profile
HAVING COUNT(*) >= 50;

[User] Sort the result by average_age ascending.

[Assistant]
SELECT risk_profile, AVG(EXTRACT(YEAR FROM AGE(current_date, date_of_birth)))::numeric(5,2) AS average_age, COUNT(*) AS customer_count
FROM financial_services.customers
GROUP BY risk_profile
HAVING COUNT(*) >= 50
ORDER BY average_age ASC;

[User] Show me all wallet addresses along with their public keys and balances, but only for wallets that have a balance greater than 1000.

[Assistant] SELECT w.address_id, a.public_key, a.balance FROM blockchain.wallets w JOIN blockchain.addresses a ON w.address_id = a.address_id WHERE a.balance > 1000;

[User] Now filter these results to only show wallets where the private_key starts with '0x1'.

[Assistant] SELECT w.address_id, a.public_key, a.balance FROM blockchain.wallets w JOIN blockchain.addresses a ON w.address_id = a.address_id WHERE a.balance > 1000 AND w.private_key LIKE '0x1%';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement. ##Table Structure
CREATE TABLE gaming_technology.in_game_items ( item_id.uuid, game_id.uuid, item_name.text, item_type.text, description.text, rarity.text, cost_currency.text, cost_amount.numeric, attributes.jsonb )
##Table Structure
CREATE TABLE healthcare.patients ( patient_id text PRIMARY KEY, first_name text, last_name text, date_of_birth date, gender text, address text, phone_number text, email text, emergency_contact_name text, emergency_contact_phone text, created_at timestamp, updated_at timestamp )
CREATE TABLE healthcare.doctors ( doctor_id text PRIMARY KEY, first_name text, last_name text, specialty text, license_number text, phone_number text, email text, hospital_affiliation_id text, created_at timestamp, updated_at timestamp )
CREATE TABLE healthcare.medical_records ( record_id text PRIMARY KEY, patient_id text, appointment_id text, doctor_id text, record_date timestamp, chief_complaint text, present_illness_history text, past_medical_history text, physical_examination_notes text, assessment text, treatment_plan text, vitals text, created_at timestamp )
CREATE TABLE healthcare.diagnoses ( diagnosis_id text PRIMARY KEY, record_id text, patient_id text, doctor_id text, diagnosis_code text, code_type text, description text, diagnosis_date date, status text, is_chronic boolean )
CREATE TABLE healthcare.medications ( medication_id text PRIMARY KEY, medication_name text, generic_name text, manufacturer text, ndc_code text, description text )
CREATE TABLE healthcare.prescriptions ( prescription_id text PRIMARY KEY, record_id text, patient_id text, doctor_id text, medication_id text, dosage text, frequency text, route text, start_date date, end_date date, quantity_dispensed numeric, refills_allowed int, prescription_date timestamp )
##Table Structure
CREATE TABLE web3.token_transfers (
    transfer_id character varying(64) NOT NULL,  -- unique identifier for the transfer
    token_id character varying(64) NOT NULL, -- identifier of the token being transferred
    from_address character varying(128) NOT NULL, -- address of the sender
    to_address character varying(128) NOT NULL, -- address of the receiver
    value numeric(38,14) NOT NULL, -- amount of tokens transferred
    transaction_id character varying(64) NOT NULL, -- identifier of the transaction containing the transfer
    log_index integer NOT NULL, -- index of the transfer log in the transaction
    PRIMARY KEY (transfer_id)
)
##Table Structure
CREATE TABLE insurance.claims ( claim_id text PRIMARY KEY, policy_id text, customer_id text, incident_date timestamp, reported_date timestamp, description text, estimated_loss numeric, status text, settlement_amount numeric, settlement_date date, claim_handler_id text, police_report_number text )
CREATE TABLE insurance.insurance_products ( product_id text PRIMARY KEY, product_name text, product_type text, description text, base_premium numeric, coverage_details text, underwriting_rules text, is_active boolean, created_at timestamp, updated_at timestamp )
CREATE TABLE insurance.agents ( agent_id text PRIMARY KEY, first_name text, last_name text, agency_name text, license_number text, license_state text, contact_email text, contact_phone text, hire_date date, termination_date date, status text, commission_rate numeric, manager_id text )
##Table Structure
CREATE TABLE insurance.claim_documents (
    document_id character varying(64) NOT NULL, -- unique identifier for the document
    claim_id character varying(64) NOT NULL, -- identifier of the claim this document relates to (FK to claims)
    document_type character varying(50) NOT NULL, -- e.g., Police Report, Photo, Invoice, Medical Bill
    file_name character varying(255) NOT NULL, -- original name of the uploaded file
    file_path character varying(512) NOT NULL, -- storage path (e.g., S3 URL, network path)
    file_size_bytes integer, -- size of the file in bytes
    mime_type character varying(100), -- MIME type of the file (e.g., 'image/jpeg', 'application/pdf')
    uploaded_by character varying(64), -- identifier of the user/system who uploaded (FK to users/customers)
    uploaded_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- time of upload
    description text, -- optional description of the document
    PRIMARY KEY (document_id)
)
##Table Structure
CREATE TABLE healthcare.appointments (
    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment
    patient_id character varying(64) NOT NULL, -- FK to patients table
    doctor_id character varying(64) NOT NULL, -- FK to doctors table
    appointment_time timestamp with time zone NOT NULL, -- date and time of the appointment
    duration_minutes integer NOT NULL, -- expected duration in minutes
    reason text, -- reason for the visit
    status character varying(32) NOT NULL, -- e.g., Scheduled, Completed, Cancelled, No-show
    location_id character varying(64), -- FK to a potential locations/clinics table
    notes text, -- notes related to scheduling
    created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
    PRIMARY KEY (appointment_id)
)

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

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

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

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

[User] List the medication names which have never been prescribed to any patient.

[Assistant]
SELECT m.medication_name
FROM healthcare.medications m
LEFT JOIN healthcare.prescriptions p ON m.medication_id = p.medication_id
WHERE p.prescription_id IS NULL;

[User] Find pairs of token transfers within the same transaction and for the same token, where the value of one transfer is exactly twice the value of the other. Show the transaction ID, token ID, and both transfer IDs and their values.

[Assistant]
SELECT
  t1.transaction_id,
  t1.token_id,
  t1.transfer_id AS transfer_id_1,
  t1.value AS value_1,
  t2.transfer_id AS transfer_id_2,
  t2.value AS value_2
FROM web3.token_transfers AS t1
JOIN web3.token_transfers AS t2
  ON t1.transaction_id = t2.transaction_id
  AND t1.token_id = t2.token_id
  AND t1.transfer_id < t2.transfer_id
WHERE
  t1.value = 2 * t2.value
  OR t2.value = 2 * t1.value;

[User] Show me the product name, product type, and the first and last name of all agents who have sold policies of each insurance product.

[Assistant]
SELECT ip.product_name, ip.product_type, a.first_name, a.last_name
FROM insurance.policies p
JOIN insurance.insurance_products ip ON p.product_id = ip.product_id
JOIN insurance.agents a ON p.agent_id = a.agent_id;

[User] Find the earliest uploaded document for each claim. Show the claim_id, document_id, file_name, and uploaded_at.

[Assistant]
SELECT cd.claim_id, cd.document_id, cd.file_name, cd.uploaded_at
FROM insurance.claim_documents cd
INNER JOIN (
  SELECT claim_id, MIN(uploaded_at) AS min_uploaded_at
  FROM insurance.claim_documents
  GROUP BY claim_id
) latest_docs
ON cd.claim_id = latest_docs.claim_id AND cd.uploaded_at = latest_docs.min_uploaded_at;

[User] List the total number of appointments for each status and also show the latest appointment_time for each status.

[Assistant]
SELECT status, COUNT(*) AS total_appointments, MAX(appointment_time) AS latest_appointment_time
FROM healthcare.appointments
GROUP BY status;