System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE gaming_technology.players ( player_id uuid PRIMARY KEY, username text, email text, password_hash text, registration_date timestamptz, last_login timestamptz, country_code text, status text, profile_data jsonb )
CREATE TABLE gaming_technology.games ( game_id uuid PRIMARY KEY, title text, developer_id uuid, publisher_id uuid, genre text, release_date date, description text, platform text, engine text, website text )
CREATE TABLE gaming_technology.game_sessions ( session_id uuid PRIMARY KEY, player_id uuid, game_id uuid, server_id uuid, start_time timestamptz, end_time timestamptz, duration_seconds int, score int, session_data jsonb )
CREATE TABLE gaming_technology.servers (
    server_id uuid NOT NULL DEFAULT gen_random_uuid(), -- unique identifier for the game server instance
    game_id uuid NOT NULL, -- FK linking to the game this server hosts
    server_name character varying(150), -- display name for the server
    region character varying(50) NOT NULL, -- geographical region (e.g., us-east-1, eu-west-2)
    ip_address character varying(45), -- IP address (IPv4 or IPv6)
    port integer, -- network port number
    current_players integer NOT NULL DEFAULT 0, -- number of players currently connected
    max_players integer NOT NULL, -- maximum player capacity
    status character varying(30) NOT NULL DEFAULT 'offline', -- server status (e.g., online, offline, maintenance)
    last_heartbeat timestamp with time zone, -- last time the server reported its status
    PRIMARY KEY (server_id)
    -- FOREIGN KEY (game_id) REFERENCES gaming_technology.games(game_id)
)
CREATE TABLE gaming_technology.achievements ( achievement_id.uuid, game_id.uuid, name.text, description.text, icon_url.text, points.integer, hidden.boolean )
CREATE TABLE gaming_technology.player_achievements ( player_achievement_id.uuid, player_id.uuid, achievement_id.uuid, unlocked_at.timestamptz )
CREATE TABLE gaming_technology.in_game_items ( item_id uuid NOT NULL DEFAULT gen_random_uuid(), game_id uuid NOT NULL, item_name character varying(150) NOT NULL, item_type character varying(50) NOT NULL, description text, rarity character varying(30), cost_currency character varying(10), cost_amount numeric(12, 2), attributes jsonb, PRIMARY KEY (item_id) )
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's the average session duration and average score per game genre?

[Assistant]
SELECT g.genre,
       AVG(gs.duration_seconds) AS avg_duration,
       AVG(gs.score) AS avg_score
FROM gaming_technology.game_sessions gs
JOIN gaming_technology.games g ON gs.game_id = g.game_id
GROUP BY g.genre;

[User] Can you show the count of sessions as well for each genre?

[Assistant]
SELECT g.genre,
       COUNT(gs.session_id) AS total_sessions,
       AVG(gs.duration_seconds) AS avg_duration,
       AVG(gs.score) AS avg_score
FROM gaming_technology.game_sessions gs
JOIN gaming_technology.games g ON gs.game_id = g.game_id
GROUP BY g.genre;

[User] Only include genres with more than 100 sessions.

[Assistant]
SELECT g.genre,
       COUNT(gs.session_id) AS total_sessions,
       AVG(gs.duration_seconds) AS avg_duration,
       AVG(gs.score) AS avg_score
FROM gaming_technology.game_sessions gs
JOIN gaming_technology.games g ON gs.game_id = g.game_id
GROUP BY g.genre
HAVING COUNT(gs.session_id) > 100;

[User] Finally, sort the results by average score descending.

[Assistant]
SELECT g.genre,
       COUNT(gs.session_id) AS total_sessions,
       AVG(gs.duration_seconds) AS avg_duration,
       AVG(gs.score) AS avg_score
FROM gaming_technology.game_sessions gs
JOIN gaming_technology.games g ON gs.game_id = g.game_id
GROUP BY g.genre
HAVING COUNT(gs.session_id) > 100
ORDER BY avg_score DESC;


System:
You are an expert in writing database language and you can refuse the user's question if the question is not related to the table structure. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE train_station_management.trains ( train_id text PRIMARY KEY, train_number text UNIQUE, model text, manufacturer text, year_manufactured int, capacity int, status text, last_maintenance_date date, next_maintenance_date date )

[User] What is the ticket price for a journey on train number T4321?

[Assistant] I'm sorry, but I don't have access to information about ticket prices for specific trains. The data I have is limited to train details such as model, manufacturer, capacity, and maintenance schedules. For ticket pricing, please consult the ticketing office or the official website.


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE insurance.policies ( policy_id.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.insurance_products ( product_id.text, product_name.text, product_type.text, description.text, base_premium.numeric, coverage_details.text, underwriting_rules.text, is_active.boolean, created_at.timestamp, updated_at.timestamp )

[User] List policy IDs and policy numbers for policies that have a null cancellation reason.

[Assistant] SELECT policy_id, policy_number FROM insurance.policies WHERE cancellation_reason IS 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 social_media.comments ( comment_id character varying(64) NOT NULL, post_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, parent_comment_id character varying(64), content text NOT NULL, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (comment_id) )
CREATE TABLE social_media.likes ( like_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL, post_id character varying(64), comment_id character varying(64), created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (like_id), CONSTRAINT unique_user_like UNIQUE (user_id, post_id, comment_id), CONSTRAINT check_like_target CHECK (post_id IS NOT NULL OR comment_id IS NOT NULL) )
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.conversations ( conversation_id character varying(64) NOT NULL, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, last_message_at timestamp, is_group_chat boolean NOT NULL DEFAULT false, group_name character varying(100), PRIMARY KEY (conversation_id) )
CREATE TABLE social_media.notifications ( notification_id character varying(64) NOT NULL, recipient_user_id character varying(64) NOT NULL, sender_user_id character varying(64), notification_type character varying(30) NOT NULL, target_entity_id character varying(64), target_entity_type character varying(20), created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, read_at timestamp, PRIMARY KEY (notification_id) )
CREATE TABLE social_media.user_settings ( setting_id character varying(64) NOT NULL, user_id character varying(64) NOT NULL UNIQUE, theme character varying(20) DEFAULT 'light', email_notifications_enabled boolean DEFAULT true, push_notifications_enabled boolean DEFAULT true, private_profile boolean DEFAULT false, updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (setting_id) )

[User] Show me the usernames and group names for all users who received a 'mention' notification related to group conversations, and when those notifications were created.

[Assistant]
SELECT us.user_id, us.theme AS username, c.group_name, n.created_at
FROM social_media.notifications n
JOIN social_media.conversations c
  ON n.target_entity_id = c.conversation_id AND n.target_entity_type = 'conversation' AND c.is_group_chat = true
JOIN social_media.user_settings us
  ON n.recipient_user_id = us.user_id
WHERE n.notification_type = 'mention';

[User] Actually, only include notifications sent after June 1, 2024.

[Assistant]
SELECT us.user_id, us.theme AS username, c.group_name, n.created_at
FROM social_media.notifications n
JOIN social_media.conversations c
  ON n.target_entity_id = c.conversation_id AND n.target_entity_type = 'conversation' AND c.is_group_chat = true
JOIN social_media.user_settings us
  ON n.recipient_user_id = us.user_id
WHERE n.notification_type = 'mention'
  AND n.created_at > '2024-06-01';

[User] Show only users whose theme is set to 'light' and the group name contains the word 'Team'.

[Assistant]
SELECT us.user_id, us.theme AS username, c.group_name, n.created_at
FROM social_media.notifications n
JOIN social_media.conversations c
  ON n.target_entity_id = c.conversation_id AND n.target_entity_type = 'conversation' AND c.is_group_chat = true
JOIN social_media.user_settings us
  ON n.recipient_user_id = us.user_id
WHERE n.notification_type = 'mention'
  AND n.created_at > '2024-06-01'
  AND us.theme = 'light'
  AND c.group_name ILIKE '%Team%';


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

[User] Find all insurance plans that have both a contact phone number and a website listed, showing their provider and plan type.

[Assistant] SELECT insurance_provider, plan_type FROM healthcare.insurance_plans WHERE contact_phone IS NOT NULL AND website 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
// db.createCollection('stations')
// Optional: Add unique index: db.stations.createIndex({ station_id: 1 }, { unique: true })
{
  _id: ObjectId(), // Auto-generated MongoDB ID
  station_id: "station_xyz", // String (unique identifier, corresponds to SQL PK)
  station_name: "Grand Central Terminal", // String
  city: "New York", // String
  state_province: "NY", // String
  country_code: "USA", // String
  address: "89 E 42nd St, New York, NY 10017", // String
  timezone: "America/New_York", // String
  number_of_platforms: 44, // Int32
  created_at: ISODate("2023-01-15T10:00:00Z"), // Date
  last_updated_at: ISODate("2023-10-28T15:30:00Z") // Date
}
// db.createCollection('trains')
// Optional: db.trains.createIndex({ train_id: 1 }, { unique: true })
// Optional: db.trains.createIndex({ train_number: 1 }, { unique: true })
{
  _id: ObjectId(),
  train_id: "train_789", // String (unique)
  train_number: "Acela 2151", // String (unique)
  model: "Siemens Velaro", // String
  manufacturer: "Siemens", // String
  year_manufactured: 2010, // Int32
  capacity: 304, // Int32
  status: "Active", // String ('Active', 'Maintenance', 'Retired')
  last_maintenance_date: ISODate("2023-09-15"), // Date (Date part only relevant)
  next_maintenance_date: ISODate("2024-03-15") // Date (Date part only relevant)
}
// db.createCollection('bookings')
// Optional: db.bookings.createIndex({ booking_id: 1 }, { unique: true })
// Optional: db.bookings.createIndex({ passenger_id: 1 })
// Optional: db.bookings.createIndex({ schedule_id: 1 })
{
  _id: ObjectId(),
  booking_id: "book_zyx", // String (unique)
  passenger_id: "pass_pqr", // String (references passengers.passenger_id)
  schedule_id: "sched_1122", // String (references schedules.schedule_id)
  booking_datetime: ISODate("2024-04-15T14:30:00Z"), // Date
  status: "Confirmed", // String ('Confirmed', 'Cancelled', 'Pending')
  total_price: 150.75, // Decimal128 or Double
  currency_code: "USD", // String
  special_requests: "Wheelchair assistance required at origin" // String
}
// db.createCollection('staff')
// Optional: db.staff.createIndex({ staff_id: 1 }, { unique: true })
// Optional: db.staff.createIndex({ employee_number: 1 }, { unique: true })
// Optional: db.staff.createIndex({ contact_email: 1 }, { unique: true, sparse: true })
{
  _id: ObjectId(),
  staff_id: "staff_mno", // String (unique)
  first_name: "Bob", // String
  last_name: "Jones", // String
  role: "Conductor", // String
  primary_station_id: null, // String (references stations.station_id, nullable)
  employee_number: "E12345", // String (unique)
  hire_date: ISODate("2018-06-01"), // Date
  contact_email: "bob.jones@example-rail.com", // String (unique, sparse)
  contact_phone: "+15559876543", // String
  is_active: true // Boolean
}

[User] Can you help me count the total number of active staff members in the database?

[Assistant] db.staff.countDocuments({ is_active: true });


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.securities (
    security_id character varying(64) NOT NULL, -- unique identifier for the security
    ticker_symbol character varying(20) NOT NULL UNIQUE, -- stock ticker or fund symbol
    isin_code character varying(12) UNIQUE, -- International Securities Identification Number
    cusip_code character varying(9) UNIQUE, -- CUSIP number
    security_name text NOT NULL, -- full name of the security
    security_type character varying(50) NOT NULL, -- e.g., Stock, Bond, ETF, Mutual Fund, Option, Future
    exchange character varying(50), -- primary exchange where traded (e.g., NYSE, NASDAQ)
    currency character varying(3) NOT NULL, -- currency the security is denominated in
    issuer_name character varying(255), -- name of the issuing entity
    sector character varying(100), -- industry sector
    last_updated timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (security_id)
)

[User] List pairs of securities that trade on different exchanges but belong to the same sector, showing ticker_symbol of both as symbol_a and symbol_b, their exchanges, and the sector.

[Assistant]
SELECT a.ticker_symbol AS symbol_a, a.exchange AS exchange_a, b.ticker_symbol AS symbol_b, b.exchange AS exchange_b, a.sector
FROM financial_services.securities a
JOIN financial_services.securities b
  ON a.sector = b.sector
  AND a.exchange <> b.exchange
WHERE a.ticker_symbol < b.ticker_symbol;

[User] Actually, exclude any pairs where the sector is NULL and ensure uniqueness by requiring symbol_a < symbol_b.

[Assistant]
SELECT a.ticker_symbol AS symbol_a, a.exchange AS exchange_a, b.ticker_symbol AS symbol_b, b.exchange AS exchange_b, a.sector
FROM financial_services.securities a
JOIN financial_services.securities b
  ON a.sector = b.sector
  AND a.exchange <> b.exchange
WHERE a.sector IS NOT NULL
  AND a.ticker_symbol < b.ticker_symbol;

[User] Now also order the results by sector ascending and symbol_a ascending.

[Assistant]
SELECT a.ticker_symbol AS symbol_a, a.exchange AS exchange_a, b.ticker_symbol AS symbol_b, b.exchange AS exchange_b, a.sector
FROM financial_services.securities a
JOIN financial_services.securities b
  ON a.sector = b.sector
  AND a.exchange <> b.exchange
WHERE a.sector IS NOT NULL
  AND a.ticker_symbol < b.ticker_symbol
ORDER BY a.sector ASC, a.ticker_symbol ASC;

[User] Finally, only include pairs where both securities are denominated in USD.

[Assistant]
SELECT a.ticker_symbol AS symbol_a, a.exchange AS exchange_a, b.ticker_symbol AS symbol_b, b.exchange AS exchange_b, a.sector
FROM financial_services.securities a
JOIN financial_services.securities b
  ON a.sector = b.sector
  AND a.exchange <> b.exchange
WHERE a.sector IS NOT NULL
  AND a.currency = 'USD'
  AND b.currency = 'USD'
  AND a.ticker_symbol < b.ticker_symbol
ORDER BY a.sector ASC, a.ticker_symbol ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.clients ( client_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, company_name character varying(200), email character varying(128) UNIQUE NOT NULL, phone character varying(32), address text, date_registered timestamp NOT NULL, status character varying(32) NOT NULL, PRIMARY KEY (client_id) )
CREATE TABLE legal_services.invoices ( invoice_id character varying(64) NOT NULL, invoice_number character varying(100) UNIQUE NOT NULL, client_id character varying(64) NOT NULL, case_id character varying(64), issue_date date NOT NULL, due_date date NOT NULL, total_amount numeric(12, 2) NOT NULL, amount_paid numeric(12, 2) DEFAULT 0.00, status character varying(50) NOT NULL, payment_date timestamp, notes text, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (invoice_id) )

[User] Find all invoices that are currently overdue. Include the invoice number, due date, total amount, and the client's name.

[Assistant] SELECT i.invoice_number, i.due_date, i.total_amount, c.first_name, c.last_name FROM legal_services.invoices i JOIN legal_services.clients c ON i.client_id = c.client_id WHERE i.status = 'Overdue' AND i.due_date < CURRENT_DATE;

[User] Only show overdue invoices for clients from the company 'Acme Corporation'.

[Assistant] SELECT i.invoice_number, i.due_date, i.total_amount, c.first_name, c.last_name FROM legal_services.invoices i JOIN legal_services.clients c ON i.client_id = c.client_id WHERE i.status = 'Overdue' AND i.due_date < CURRENT_DATE AND c.company_name = 'Acme Corporation';

[User] Sort the results by the due date, from oldest to newest.

[Assistant] SELECT i.invoice_number, i.due_date, i.total_amount, c.first_name, c.last_name FROM legal_services.invoices i JOIN legal_services.clients c ON i.client_id = c.client_id WHERE i.status = 'Overdue' AND i.due_date < CURRENT_DATE AND c.company_name = 'Acme Corporation' ORDER BY i.due_date ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE smart_money_token_performance ( token_address.text, token_symbol.text, pnl.numeric, net_flow.numeric, avg_cost.numeric, price.numeric, realized_ratio.numeric, roi.numeric, chain.text )

[User] List all smart money addresses that have a negative PNL but a positive Realized Ratio. Show the address, chain, PNL, and Realized Ratio.

[Assistant] SELECT token_address, chain, pnl, realized_ratio FROM smart_money_token_performance WHERE pnl < 0 AND realized_ratio > 0

[User] Can you refine the results to only include addresses where the absolute value of PNL is greater than 1000?

[Assistant] SELECT token_address, chain, pnl, realized_ratio FROM smart_money_token_performance WHERE pnl < -1000 AND realized_ratio > 0


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE transportation.vehicles ( vehicle_id.text, license_plate.text, vin.text, make.text, model.text, year.integer, type.text, capacity.integer, fuel_type.text, status.text, depot_id.text, acquisition_date.date )
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.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 )

[User] Get the total fuel cost per route, showing route_number and the sum of total_cost for all fuel logs associated with trips on that route.

[Assistant]
SELECT r.route_number,
       SUM(fl.total_cost) AS total_fuel_cost
FROM transportation.routes r
JOIN transportation.trips t ON r.route_id = t.route_id
JOIN transportation.fuel_logs fl ON t.trip_id = fl.trip_id
GROUP BY r.route_number;


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.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.medications (
    medication_id character varying(64) NOT NULL, -- unique identifier for the medication type
    medication_name character varying(255) NOT NULL, -- common or brand name
    generic_name character varying(255), -- generic chemical name
    manufacturer character varying(100), -- drug manufacturer
    ndc_code character varying(20) UNIQUE, -- National Drug Code (optional but useful)
    description text, -- description of the medication
    PRIMARY KEY (medication_id)
)
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 )

[User] List all appointments scheduled in the next 7 days along with the appointment_id, appointment_time, patient's full name, doctor's full name, and the patient's primary insurance plan_name.

[Assistant]
SELECT ap.appointment_id,
       ap.appointment_time,
       pt.first_name || ' ' || pt.last_name AS patient_name,
       d.first_name || ' ' || d.last_name AS doctor_name,
       ip.plan_name
FROM healthcare.appointments ap
JOIN healthcare.patients pt ON ap.patient_id = pt.patient_id
JOIN healthcare.doctors d ON ap.doctor_id = d.doctor_id
JOIN healthcare.patient_insurance pi ON pt.patient_id = pi.patient_id AND pi.is_primary = TRUE
JOIN healthcare.insurance_plans ip ON pi.plan_id = ip.plan_id
WHERE ap.appointment_time BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '7 days';


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.services ( service_id.text, property_id.text, service_name.text, description.text, category.text, price.numeric, unit.text, is_available.boolean, department.text )

[User] Calculate the average price for services within each category.

[Assistant] SELECT category, AVG(price) FROM hospitality_technology.services GROUP BY category;

[User] Only include categories where the calculated average price is less than 75.

[Assistant] SELECT category, AVG(price) FROM hospitality_technology.services GROUP BY category HAVING AVG(price) < 75;

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

[Assistant] SELECT category, AVG(price) FROM hospitality_technology.services GROUP BY category HAVING AVG(price) < 75 ORDER BY AVG(price) 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 hospitality_technology.properties ( property_id text, property_name text, address_line1 text, address_line2 text, city text, state_province text, postal_code text, country_code text, phone_number text, email_address text, property_type text, star_rating numeric, timezone text, manager_staff_id text, created_at timestamp, updated_at timestamp )
CREATE TABLE hospitality_technology.payments (
    payment_id character varying(64) NOT NULL,  -- unique identifier for the payment transaction
    reservation_id character varying(64), -- FK to reservations (if payment is for a stay)
    guest_id character varying(64) NOT NULL, -- FK to guests (who paid)
    bill_id character varying(64), -- FK to bills/invoices this payment applies to
    amount numeric(12,2) NOT NULL, -- amount of the payment
    currency_code character varying(3) NOT NULL, -- ISO currency code (e.g., USD, EUR)
    payment_method character varying(50) NOT NULL, -- e.g., CreditCard, Cash, BankTransfer, Points, Voucher
    card_type character varying(50), -- e.g., Visa, MasterCard, Amex (if CC)
    card_last_four character varying(4), -- last 4 digits of CC (if CC)
    transaction_ref character varying(128), -- reference ID from payment gateway or processor
    payment_timestamp timestamp with time zone NOT NULL DEFAULT current_timestamp, -- when the payment occurred
    status character varying(50) NOT NULL, -- e.g., Pending, Succeeded, Failed, Refunded, Disputed
    staff_id_processed character varying(64), -- FK to staff (who processed the payment)
    notes text, -- notes about the payment
    PRIMARY KEY (payment_id),
    FOREIGN KEY (reservation_id) REFERENCES hospitality_technology.reservations(reservation_id),
    FOREIGN KEY (guest_id) REFERENCES hospitality_technology.guests(guest_id),
    FOREIGN KEY (staff_id_processed) REFERENCES hospitality_technology.staff(staff_id)
)

[User] Show me the payment amount and the name of the property associated with each payment record.

[Assistant]
SELECT
  p.amount,
  prop.property_name
FROM hospitality_technology.payments AS p
JOIN hospitality_technology.reservations AS r ON p.reservation_id = r.reservation_id -- Assuming reservations links payments and properties
JOIN hospitality_technology.properties AS prop ON r.property_id = prop.property_id;

[User] Now, filter this list to only include payments with a status of 'Succeeded' and sort by payment amount in descending order.

[Assistant]
SELECT
  p.amount,
  prop.property_name
FROM hospitality_technology.payments AS p
JOIN hospitality_technology.reservations AS r ON p.reservation_id = r.reservation_id
JOIN hospitality_technology.properties AS prop ON r.property_id = prop.property_id
WHERE
  p.status = 'Succeeded'
ORDER BY
  p.amount DESC;


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

[User] Show the distribution of total supply for tokens, grouped into ranges like < 1 million, 1 million to 1 billion, and > 1 billion. Count how many tokens fall into each range.

[Assistant] SELECT CASE WHEN total_supply < 1000000 THEN '< 1 million' WHEN total_supply >= 1000000 AND total_supply <= 1000000000 THEN '1 million to 1 billion' WHEN total_supply > 1000000000 THEN '> 1 billion' ELSE 'Other' END AS supply_range, COUNT(*) AS token_count FROM web3.tokens GROUP BY supply_range ORDER BY CASE WHEN supply_range = '< 1 million' THEN 1 WHEN supply_range = '1 million to 1 billion' THEN 2 WHEN supply_range = '> 1 billion' THEN 3 ELSE 4 END;

[User] Instead of the count, can you show the average total supply for tokens in each range?

[Assistant] SELECT CASE WHEN total_supply < 1000000 THEN '< 1 million' WHEN total_supply >= 1000000 AND total_supply <= 1000000000 THEN '1 million to 1 billion' WHEN total_supply > 1000000000 THEN '> 1 billion' ELSE 'Other' END AS supply_range, AVG(total_supply) AS average_total_supply FROM web3.tokens GROUP BY supply_range ORDER BY CASE WHEN supply_range = '< 1 million' THEN 1 WHEN supply_range = '1 million to 1 billion' THEN 2 WHEN supply_range = '> 1 billion' THEN 3 ELSE 4 END;


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.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.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 )

[User] For each fueling event, show the fuel_log_id, vehicle_id, the full name of the assigned driver for the trip during that fueling event, and the log_timestamp.

[Assistant]
SELECT fl.fuel_log_id, fl.vehicle_id, d.first_name || ' ' || d.last_name AS driver_full_name, fl.log_timestamp
FROM transportation.fuel_logs fl
JOIN transportation.trips t ON fl.trip_id = t.trip_id
JOIN transportation.drivers d ON t.driver_id = d.driver_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 government_services.agencies ( agency_id text, agency_name text, jurisdiction_level text, primary_contact_email text, main_phone_number text, website_url text, established_date date, parent_agency_id text )
CREATE TABLE government_services.services ( service_id text, agency_id text, service_name text, description text, category text, eligibility_criteria text, standard_fee numeric, average_processing_time_days integer, is_active boolean, online_application_url text )
CREATE TABLE government_services.payments ( payment_id text, application_id text, citizen_id text, service_id text, amount numeric, currency text, payment_method text, payment_provider_reference text, payment_timestamp timestamp, status text, notes text )
CREATE TABLE government_services.employees ( employee_id text, agency_id text, first_name text, last_name text, job_title text, department text, work_email text, work_phone text, hire_date date, termination_date date, access_level text, manager_employee_id text )
CREATE TABLE government_services.notifications ( notification_id text, citizen_id text, application_id text, message_subject text, message_body text, channel text, sent_at timestamp, status text, related_entity_type text, related_entity_id text )

[User] Which agencies offer services in the 'Social Assistance' category? Show the agency name and the service name.

[Assistant]
SELECT a.agency_name, s.service_name
FROM government_services.services s
JOIN government_services.agencies a ON s.agency_id = a.agency_id
WHERE s.category = 'Social Assistance';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.wallets ( wallet_id text, user_id text, address text, private_key text, created_at timestamp )
CREATE TABLE trading_platform.orders ( order_id text, user_id text, wallet_id text, asset_id text, order_type text, quantity numeric, price numeric, status text, created_at timestamp )
CREATE TABLE trading_platform.trades ( trade_id text, order_id text, buyer_id text, seller_id text, asset_id text, quantity numeric, price numeric, traded_at timestamp )
CREATE TABLE trading_platform.assets ( asset_id text, name text, symbol text, type text )
CREATE TABLE trading_platform.dapps ( dapp_id text, name text, description text, url text )
CREATE TABLE trading_platform.peers ( peer_id text, ip_address text, port integer, last_seen timestamp )
CREATE TABLE trading_platform.metadata ( metadata_id text, asset_id text, key text, value text )
CREATE TABLE trading_platform.kyc_audit ( kyc_audit_id text, user_id text, status text, reviewed_at timestamp )
CREATE TABLE trading_platform.logs ( log_id text, user_id text, action text, details text, logged_at timestamp )

[User] List user IDs with approved KYC status and the addresses of their wallets.

[Assistant] SELECT DISTINCT w.user_id, w.address FROM trading_platform.wallets w JOIN trading_platform.kyc_audit k ON w.user_id = k.user_id WHERE k.status = 'approved';

[User] From that list, also show the total number of unspent UTXOs associated with each wallet address.

[Assistant] SELECT w.user_id, w.address, COUNT(u.utxo_id) AS unspent_utxo_count FROM trading_platform.wallets w JOIN trading_platform.kyc_audit k ON w.user_id = k.user_id JOIN trading_platform.utxos u ON w.address = u.address WHERE k.status = 'approved' AND u.spent = FALSE GROUP BY w.user_id, w.address;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE transportation.vehicles ( vehicle_id.text, license_plate.text, vin.text, make.text, model.text, year.integer, type.text, capacity.integer, fuel_type.text, status.text, depot_id.text, acquisition_date.date )
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.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.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 )

[User] Show me all vehicles that had maintenance in the past month, including their make, model, maintenance service_date, and depot name.

[Assistant]
SELECT v.vehicle_id,
       v.make,
       v.model,
       m.service_date,
       l.name AS depot_name
FROM transportation.maintenance_logs AS m
JOIN transportation.vehicles AS v
  ON m.vehicle_id = v.vehicle_id
LEFT JOIN transportation.locations AS l
  ON v.depot_id = l.location_id
WHERE m.service_date >= CURRENT_DATE - INTERVAL '1 month';

[User] Now, include only those records where the maintenance cost is greater than 500, and order the results by cost descending.

[Assistant]
SELECT v.vehicle_id,
       v.make,
       v.model,
       m.service_date,
       m.cost,
       l.name AS depot_name
FROM transportation.maintenance_logs AS m
JOIN transportation.vehicles AS v
  ON m.vehicle_id = v.vehicle_id
LEFT JOIN transportation.locations AS l
  ON v.depot_id = l.location_id
WHERE m.service_date >= CURRENT_DATE - INTERVAL '1 month'
  AND m.cost > 500
ORDER BY m.cost 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 narrative_info (",
    "narrative character varying(512) NOT NULL, -- the id of narrative",
    "top_3_coins text, -- the top 3 tokens in the narrative",
    "price_change_percentage_1h double precision, -- change in value divided by the absolute price value of the original token price in 1 hour in the narrative",
    "price_change_percentage_24h double precision, -- change in value divided by the absolute price value of the original token price in 24 hours in the narrative",
    "price_change_percentage_7d double precision, -- change in value divided by the absolute price value of the original token price in 7 days in the narrative",
    "market_cap double precision, -- the market cap of the narrative",
    "volume_24h double precision, -- the trade volume of the narrative",
    "trend_rank bigint, -- the trending rank of the narrative, value 1 expresses the most popular narrative",
    "token_num bigint, -- total token number in the narrative",
    ",PRIMARY KEY (narrative));"

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

  "CREATE TABLE smart_money_profit (",
    "address character varying(100) NOT NULL, -- the user's address",
    "rank INT, -- the rank of the address in trade performance, value 1 expresses the best address.",
    "profit numeric(38,6), -- the profit user made in a month",
    "roi numeric(38,2), -- the roi of the user in a month",
    "realized_ratio numeric(38,2), -- the percentage of the user's realized profit",
    "most_profit_token character varying(100), -- the token symbol of the user's most profitable trade",
    "last_trade_time character varying(100), -- the last trade time of the user",
    "chain character varying(100), -- the chain that the address resides",
    "PRIMARY KEY (address, chain));",

  "CREATE TABLE smart_money_token_inflow (",
    "token_address character varying(100) NOT NULL, -- the token's address",
    "token_symbol character varying(100), -- the tokens's symbol",
    "token_amount numeric(38,2), -- the absolute value of the amount if user bought minus  the amount user sold of this token",
    "usd_value numeric(38,2), -- the absolute usd value of the bought token minus sold token",
    "avg_price numeric(38,6), -- the average cost price of user spent on this token",
    "type int, -- the direction of the trade on this token. 1 means buying, 2 means selling",
    "address_amount integer, -- the amount of the user bought this token",
    "narrative character varying(100), -- the category or narrative of the token",
    "chain character varying(100), -- the chain that the token resides",
    ",PRIMARY KEY (token_address, chain)",

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

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

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

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

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

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

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

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


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE erc20_balances ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )
CREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )
CREATE TABLE nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )
CREATE TABLE sui_coins ( object_id varchar NOT NULL, status varchar NOT NULL, coin_type varchar NOT NULL, balance varchar NOT NULL, owner varchar NOT NULL )
CREATE TABLE sui_coins_metadata ( object_id varchar NOT NULL, coin_type varchar NOT NULL, status varchar NOT NULL, decimals bigint NOT NULL, description varchar NOT NULL, icon_url varchar NOT NULL, symbol varchar NOT NULL, name varchar NOT NULL )
CREATE TABLE nft_metadata ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, token_id varchar NOT NULL, contract_name varchar NOT NULL, erc_type varchar NOT NULL, amount bigint NOT NULL, minter varchar NOT NULL, owner varchar NOT NULL, mint_block_number bigint NOT NULL, mint_time bigint NOT NULL, mint_transaction_hash varchar NOT NULL, mint_price varchar NOT NULL, token_uri varchar NOT NULL, metadata varchar NOT NULL, name varchar NOT NULL, image_uri varchar NOT NULL, traits varchar NOT NULL, updated_at bigint NOT NULL, status varchar NOT NULL, rarity_score real NOT NULL, rarity_rank integer NOT NULL, unique_attribute_count integer NOT NULL, pk integer NOT NULL )
CREATE TABLE token_prices_latest ( blockchain varchar(36) NOT NULL, address varchar(42) NOT NULL, decimals bigint NOT NULL, symbol varchar(36) NOT NULL, price real NOT NULL, timestamp timestamp(6) NOT NULL )
CREATE TABLE token_balances ( block_number bigint NOT NULL, block_timestamp timestamp(3) NOT NULL, tick varchar NOT NULL, wallet_address varchar(42) NOT NULL, total_supply decimal(38,0) NOT NULL, amount decimal(38,0) NOT NULL )
CREATE TABLE token_info ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL )
CREATE TABLE mud_holesky_redstone ( address varchar NOT NULL, table_id varchar NOT NULL, key_bytes varchar NOT NULL, key0 varchar NOT NULL, key1 varchar NOT NULL, static_data varchar NOT NULL, encoded_lengths varchar NOT NULL, dynamic_data varchar NOT NULL, is_deleted boolean NOT NULL, block_number bigint NOT NULL, log_index bigint NOT NULL )
CREATE TABLE token_info_bitcoin ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, tick varchar(255) NOT NULL, max_supply decimal(38,0) NOT NULL, lim decimal(38,0) NOT NULL, wlim decimal(38,0) NOT NULL, dec integer NOT NULL, creator varchar(42) NOT NULL )
CREATE TABLE token_activities_bitcoin ( block_timestamp timestamp(3) NOT NULL, block_number bigint NOT NULL, tx_index integer NOT NULL, tx_hash varchar(66) NOT NULL, log_index integer NOT NULL, type varchar(20) NOT NULL, tick varchar(255) NOT NULL, id varchar(255) NOT NULL, amt decimal(38,0) NOT NULL, from_address varchar(62) NOT NULL, to_address varchar(62) NOT NULL )

[User] List all NFTs minted on the Ethereum blockchain in the last 14 days, including their contract address, token ID, name, and minter.

[Assistant]
SELECT contract_address, token_id, name, minter
FROM nft_metadata
WHERE blockchain = 'Ethereum' AND mint_time >= (extract(epoch FROM now()) - 14*24*60*60);

[User] Show also the collection name for each NFT by joining with the nft_collections table.

[Assistant]
SELECT nm.contract_address, nm.token_id, nm.name, nm.minter, nc.name AS collection_name
FROM nft_metadata nm
JOIN nft_collections nc ON nm.blockchain = nc.blockchain AND nm.contract_address = nc.contract_address
WHERE nm.blockchain = 'Ethereum' AND nm.mint_time >= (extract(epoch FROM now()) - 14*24*60*60);

[User] I only want NFTs where the rarity_score is above 80, and order the results by rarity_score descending.

[Assistant]
SELECT nm.contract_address, nm.token_id, nm.name, nm.minter, nc.name AS collection_name, nm.rarity_score
FROM nft_metadata nm
JOIN nft_collections nc ON nm.blockchain = nc.blockchain AND nm.contract_address = nc.contract_address
WHERE nm.blockchain = 'Ethereum' AND nm.mint_time >= (extract(epoch FROM now()) - 14*24*60*60)
  AND nm.rarity_score > 80
ORDER BY nm.rarity_score DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE healthcare.appointments ( appointment_id character varying(64) NOT NULL, patient_id character varying(64) NOT NULL, doctor_id character varying(64) NOT NULL, appointment_time timestamp with time zone NOT NULL, duration_minutes integer NOT NULL, reason text, status character varying(32) NOT NULL, location_id character varying(64), notes text, created_at timestamp with time zone NOT NULL DEFAULT current_timestamp, PRIMARY KEY (appointment_id) )

[User] Show the total number of appointments created in 2024 for each doctor and each status.

[Assistant] SELECT doctor_id, status, COUNT(*) AS appointment_count FROM healthcare.appointments WHERE EXTRACT(YEAR FROM created_at) = 2024 GROUP BY doctor_id, status;

[User] Only include combinations where the count is greater than 5.

[Assistant] SELECT doctor_id, status, COUNT(*) AS appointment_count FROM healthcare.appointments WHERE EXTRACT(YEAR FROM created_at) = 2024 GROUP BY doctor_id, status HAVING COUNT(*) > 5;

[User] Sort the results by doctor ID ascending and then by appointment count descending.

[Assistant] SELECT doctor_id, status, COUNT(*) AS appointment_count FROM healthcare.appointments WHERE EXTRACT(YEAR FROM created_at) = 2024 GROUP BY doctor_id, status HAVING COUNT(*) > 5 ORDER BY doctor_id ASC, appointment_count DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE erc1155_approval_for_all (
    block_number bigint NOT NULL, -- Block number containing the transaction
    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the transaction
    transaction_index integer NOT NULL, -- Index of the transaction within the block
    transaction_hash varchar(66) NOT NULL, -- Transaction hash
    log_index integer NOT NULL, -- Log index
    contract_address varchar(42) NOT NULL  -- Event contract address
)
CREATE TABLE erc20_balances_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )
CREATE TABLE nft_holders ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk varchar NOT NULL )
CREATE TABLE nft_holder_historical ( block_number bigint NOT NULL, contract_address varchar NOT NULL, wallet_address varchar NOT NULL, token_id varchar NOT NULL, contract_type varchar NOT NULL, amount varchar NOT NULL, pk integer NOT NULL )
CREATE TABLE sui_nfts ( object_id text, status text, collection_type text, package_id text, previous_transaction text, display text, owner text, name text )
CREATE TABLE nft_metadata ( blockchain text, contract_address text, token_id text, contract_name text, erc_type text, amount bigint, minter text, owner text, mint_block_number bigint, mint_time bigint, mint_transaction_hash text, mint_price text, token_uri text, metadata text, name text, image_uri text, traits text, updated_at bigint, status text, rarity_score real, rarity_rank integer, unique_attribute_count integer, pk integer )
CREATE TABLE nft_collections ( blockchain varchar NOT NULL, contract_address varchar NOT NULL, name varchar NOT NULL, symbol varchar NOT NULL, deploy_block_number bigint NOT NULL, deploy_block_time bigint NOT NULL, erc_type varchar NOT NULL, owner varchar NOT NULL, traits varchar NOT NULL, description varchar NOT NULL, slug varchar NOT NULL, media_info varchar NOT NULL, image_url varchar NOT NULL, banner_image_url varchar NOT NULL, updated_at bigint NOT NULL, banner varchar NOT NULL, token_count bigint NOT NULL, floor_price varchar NOT NULL, floor_price_symbol varchar NOT NULL, floor_price_contract varchar NOT NULL, pk integer NOT NULL )
CREATE TABLE token_prices ( uuid text, blockchain text, address text, decimals bigint, symbol text, price real, timestamp timestamp )
CREATE TABLE token_prices_latest (
    blockchain varchar(36) NOT NULL, -- blockchain fields for the functionType  in contract
    address varchar(42) NOT NULL, -- address fields for the functionType  in contract
    decimals bigint NOT NULL, -- decimals fields for the functionType  in contract
    symbol varchar(36) NOT NULL, -- symbol fields for the functionType  in contract
    price real NOT NULL, -- price fields for the functionType  in contract
    timestamp timestamp(6) NOT NULL  -- timestamp fields for the functionType  in contract
)
CREATE TABLE erc20_approval ( block_number bigint NOT NULL, block_timestamp timestamp(6) NOT NULL, transaction_index integer NOT NULL, transaction_hash varchar NOT NULL, log_index integer NOT NULL, contract_address varchar NOT NULL, pk integer NOT NULL )
CREATE TABLE token_info (
    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)
    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)
    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)
    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)
    tick varchar NOT NULL, -- Token tick
    max_supply decimal(38,0) NOT NULL, -- Max supply
    lim decimal(38,0) NOT NULL, -- Limit of each mint
    wlim decimal(38,0) NOT NULL, -- Limit of each address can maximum mint
    dec integer NOT NULL, -- Decimal for minimum divie
    creator varchar(42) NOT NULL  -- Address originating the inscription (matches from_address in transactions table)
)
CREATE TABLE token_info_bitcoin ( block_timestamp.timestamp, block_number.bigint, tx_index.integer, tx_hash.text, tick.text, max_supply.decimal, lim.decimal, wlim.decimal, dec.integer, creator.text )
CREATE TABLE token_activities_bitcoin ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, log_index integer, type text, tick text, id text, amt decimal, from_address text, to_address text )
CREATE TABLE token_activities_avalanche (
    block_timestamp timestamp(3) NOT NULL, -- Timestamp of the block containing the inscription (matches block_timestamp in transactions table)
    block_number bigint NOT NULL, -- Block number containing the inscription (matches block_number in transactions table)
    tx_index integer NOT NULL, -- Index of the transaction containing the inscription (matches transaction_index in transactions table)
    tx_hash varchar(66) NOT NULL, -- Unique identifier of the transaction containing the inscription (matches hash in transactions table)
    log_index integer NOT NULL, -- Index of the log within the transaction
    type varchar(20) NOT NULL, -- Operation: Type of event (deploy, mint, transfer, list)
    tick varchar(255) NOT NULL, -- Ticker: Identifier of the inscription
    id varchar(255) NOT NULL, -- Unique identifier of the inscription
    amt decimal(38,0) NOT NULL, -- Amount to mint: States the amount of the inscription to operation. When operation is mint, has to be less or equal to "lim"
    from_address varchar(42) NOT NULL, -- Address sending the inscription
    to_address varchar(42) NOT NULL  -- Address receiving the inscription
)
CREATE TABLE token_balances_avalanche ( block_number bigint, block_timestamp timestamp, tick varchar, wallet_address varchar, total_supply decimal, amount decimal )
CREATE TABLE token_info_avalanche ( block_timestamp timestamp, block_number bigint, tx_index integer, tx_hash text, tick text, max_supply decimal, lim decimal, wlim decimal, dec integer, creator text, minted decimal, holders decimal, txs decimal, updated_timestamp timestamp, completed_timestamp timestamp, id text )

[User] For each Sui NFT with status 'exists', show its object ID, collection type, and owner.

[Assistant] SELECT object_id, collection_type, owner FROM sui_nfts WHERE status = 'exists';

[User] Only show NFTs whose collection_type contains 'Art'.

[Assistant] SELECT object_id, collection_type, owner FROM sui_nfts WHERE status = 'exists' AND collection_type LIKE '%Art%';

[User] Add the name and display metadata for each NFT in the result.

[Assistant] SELECT object_id, collection_type, owner, name, display FROM sui_nfts WHERE status = 'exists' AND collection_type LIKE '%Art%';

[User] Order the results by name in ascending order and limit to the first 10 entries.

[Assistant] SELECT object_id, collection_type, owner, name, display FROM sui_nfts WHERE status = 'exists' AND collection_type LIKE '%Art%' ORDER BY name ASC LIMIT 10;


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

[User] Show the route number and description for routes that have bookings associated with them.

[Assistant] SELECT DISTINCT T1.route_number, T1.description FROM transportation.routes AS T1 JOIN transportation.bookings AS T2 ON T1.route_id = T2.trip_id;

[User] For these routes, what is the average fare of the associated bookings?

[Assistant] SELECT T1.route_number, AVG(T2.fare) FROM transportation.routes AS T1 JOIN transportation.bookings AS T2 ON T1.route_id = T2.trip_id GROUP BY T1.route_number;

[User] Also, only include routes where the average fare is greater than 75.

[Assistant] SELECT T1.route_number, AVG(T2.fare) FROM transportation.routes AS T1 JOIN transportation.bookings AS T2 ON T1.route_id = T2.trip_id GROUP BY T1.route_number HAVING AVG(T2.fare) > 75;


System:
You are an 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.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)
)

[User] List all token transfers with a value greater than 1000000. Show transfer ID, token ID, from address, to address, and value.

[Assistant]
SELECT
  transfer_id,
  token_id,
  from_address,
  to_address,
  value
FROM web3.token_transfers
WHERE
  value > 1000000;

[User] Now, only show transfers for token ID '0xabc...xyz'.

[Assistant]
SELECT
  transfer_id,
  token_id,
  from_address,
  to_address,
  value
FROM web3.token_transfers
WHERE
  value > 1000000
  AND token_id = '0xabc...xyz';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE trading_platform.users ( user_id.text, username.text, email.text, password_hash.text, created_at.timestamp )
CREATE TABLE trading_platform.orders ( order_id text, user_id text, wallet_id text, asset_id text, order_type text, quantity numeric, price numeric, status text, created_at timestamp )
CREATE TABLE trading_platform.assets ( asset_id text, name text, symbol text, type text )
CREATE TABLE trading_platform.dapps ( dapp_id text, name text, description text, url text )
CREATE TABLE trading_platform.peers ( peer_id.text, ip_address.text, port.integer, last_seen.timestamp )
CREATE TABLE trading_platform.metadata ( metadata_id character varying(64) NOT NULL, asset_id character varying(64) NOT NULL, key character varying(128) NOT NULL, value text NOT NULL, PRIMARY KEY (metadata_id) )
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, user_id text, message text, sent_at timestamp, read_at timestamp )

[User] List all DApps along with the number of metadata entries linked to each, even if the DApp has no linked metadata.

[Assistant]
SELECT d.name, d.url, COUNT(m.metadata_id) AS metadata_count
FROM trading_platform.dapps d
LEFT JOIN trading_platform.metadata m ON d.dapp_id = m.asset_id
GROUP BY d.dapp_id, d.name, d.url;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE 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.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.law_firms ( firm_id character varying(64) NOT NULL, firm_name character varying(200) NOT NULL, address text NOT NULL, phone character varying(32), website character varying(255), founded_date date, managing_partner_id character varying(64), PRIMARY KEY (firm_id) )
CREATE TABLE legal_services.cases ( case_id.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.invoices ( invoice_id text, invoice_number text, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )

[User] List each client's first and last name along with the number of cases they have, alias the count as case_count.

[Assistant]
SELECT cl.first_name, cl.last_name, COUNT(c.case_id) AS case_count
FROM legal_services.clients cl
LEFT JOIN legal_services.cases c ON cl.client_id = c.client_id
GROUP BY cl.client_id, cl.first_name, cl.last_name;

[User] Actually, only include clients who have more than 2 cases.

[Assistant]
SELECT cl.first_name, cl.last_name, COUNT(c.case_id) AS case_count
FROM legal_services.clients cl
LEFT JOIN legal_services.cases c ON cl.client_id = c.client_id
GROUP BY cl.client_id, cl.first_name, cl.last_name
HAVING COUNT(c.case_id) > 2;

[User] Also sort the results by case_count descending and then by the client's last_name ascending.

[Assistant]
SELECT cl.first_name, cl.last_name, COUNT(c.case_id) AS case_count
FROM legal_services.clients cl
LEFT JOIN legal_services.cases c ON cl.client_id = c.client_id
GROUP BY cl.client_id, cl.first_name, cl.last_name
HAVING COUNT(c.case_id) > 2
ORDER BY case_count DESC, cl.last_name ASC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE insurance.customers ( customer_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, date_of_birth date NOT NULL, ssn_hash character varying(128), address_line1 character varying(255) NOT NULL, address_line2 character varying(255), city character varying(100) NOT NULL, state character varying(50) NOT NULL, zip_code character varying(20) NOT NULL, country character varying(50) NOT NULL DEFAULT 'USA', phone_number character varying(30), email character varying(128) UNIQUE, created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at timestamp, status character varying(20) NOT NULL DEFAULT 'Active', PRIMARY KEY (customer_id) )
CREATE TABLE insurance.policies ( policy_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, product_id character varying(64) NOT NULL, agent_id character varying(64), policy_number character varying(100) NOT NULL UNIQUE, start_date date NOT NULL, end_date date NOT NULL, premium_amount numeric(12, 2) NOT NULL, coverage_limit numeric(15, 2) NOT NULL, deductible numeric(10, 2) NOT NULL, status character varying(30) NOT NULL, issued_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, cancellation_date date, cancellation_reason text, PRIMARY KEY (policy_id) )
CREATE TABLE insurance.claims ( claim_id.text, policy_id.text, customer_id.text, incident_date.timestamp, reported_date.timestamp, description.text, estimated_loss.numeric, status.text, settlement_amount.numeric, settlement_date.date, claim_handler_id.text, police_report_number.text )
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 character varying(64) NOT NULL, -- unique identifier for the payment
    policy_id character varying(64) NOT NULL, -- identifier of the policy the payment is for (FK to policies)
    customer_id character varying(64) NOT NULL, -- identifier of the customer making the payment (FK to customers)
    payment_date timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- date the payment was received
    amount_paid numeric(12, 2) NOT NULL, -- amount of the payment
    payment_method character varying(50), -- e.g., Credit Card, Bank Transfer, Check
    transaction_reference character varying(128) UNIQUE, -- reference from payment processor
    due_date date, -- due date for this payment installment
    payment_period_start date, -- start date of the period this payment covers
    payment_period_end date, -- end date of the period this payment covers
    status character varying(30) NOT NULL DEFAULT 'Completed', -- e.g., Completed, Pending, Failed, Refunded
    PRIMARY KEY (payment_id)
)

[User] List each claim with its policy number and the selling agent's first and last name.

[Assistant]
SELECT c.claim_id, p.policy_number, a.first_name, a.last_name
FROM insurance.claims c
JOIN insurance.policies p ON c.policy_id = p.policy_id
LEFT JOIN insurance.agents a ON p.agent_id = a.agent_id;

[User] Filter to include only claims with settlement_amount not null and reported_date in 2023.

[Assistant]
SELECT c.claim_id, p.policy_number, a.first_name, a.last_name
FROM insurance.claims c
JOIN insurance.policies p ON c.policy_id = p.policy_id
LEFT JOIN insurance.agents a ON p.agent_id = a.agent_id
WHERE c.settlement_amount IS NOT NULL
  AND c.reported_date >= '2023-01-01'::timestamp
  AND c.reported_date < '2024-01-01'::timestamp;


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 character varying(64) NOT NULL, employee_id character varying(64) NOT NULL UNIQUE, first_name character varying(128) NOT NULL, last_name character varying(128) NOT NULL, license_number character varying(64) NOT NULL UNIQUE, license_expiry_date date NOT NULL, contact_number character varying(32), email character varying(128) UNIQUE, hire_date date NOT NULL, status character varying(32) NOT NULL, PRIMARY KEY (driver_id) )

[User] Show me all active drivers whose license will expire in the next 60 days, including their full name and contact information.

[Assistant] SELECT driver_id, first_name, last_name, contact_number, email, license_expiry_date FROM transportation.drivers WHERE status = 'active' AND license_expiry_date BETWEEN CURRENT_DATE AND (CURRENT_DATE + INTERVAL '60 days')

[User] Can you also include their hire date and order the results by license expiry date with the soonest expiring first?

[Assistant] SELECT driver_id, first_name, last_name, contact_number, email, hire_date, license_expiry_date FROM transportation.drivers WHERE status = 'active' AND license_expiry_date BETWEEN CURRENT_DATE AND (CURRENT_DATE + INTERVAL '60 days') ORDER BY license_expiry_date ASC

[User] Now filter this to only show drivers who were hired more than 3 years ago.

[Assistant] SELECT driver_id, first_name, last_name, contact_number, email, hire_date, license_expiry_date FROM transportation.drivers WHERE status = 'active' AND license_expiry_date BETWEEN CURRENT_DATE AND (CURRENT_DATE + INTERVAL '60 days') AND hire_date < (CURRENT_DATE - INTERVAL '3 years') ORDER BY license_expiry_date ASC


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE financial_services.securities ( security_id.text, ticker_symbol.text, isin_code.text, cusip_code.text, security_name.text, security_type.text, exchange.text, currency.text, issuer_name.text, sector.text, last_updated.timestamp )

[User] List pairs of securities from the same issuer where one security was updated within the last 30 days, and the other was updated more than 90 days ago. Show issuer name, ticker symbols, and last_updated timestamps for both.

[Assistant] SELECT a.issuer_name, a.ticker_symbol AS ticker_symbol_a, a.last_updated AS last_updated_a, b.ticker_symbol AS ticker_symbol_b, b.last_updated AS last_updated_b FROM financial_services.securities AS a JOIN financial_services.securities AS b ON a.issuer_name = b.issuer_name WHERE a.security_id != b.security_id AND a.last_updated >= CURRENT_DATE - INTERVAL '30 days' AND b.last_updated < CURRENT_DATE - INTERVAL '90 days';

[User] Only include issuers who have more than 5 securities in total.

[Assistant] WITH IssuerCounts AS (SELECT issuer_name, COUNT(*) AS total_securities FROM financial_services.securities WHERE issuer_name IS NOT NULL GROUP BY issuer_name HAVING COUNT(*) > 5) SELECT a.issuer_name, a.ticker_symbol AS ticker_symbol_a, a.last_updated AS last_updated_a, b.ticker_symbol AS ticker_symbol_b, b.last_updated AS last_updated_b FROM financial_services.securities AS a JOIN financial_services.securities AS b ON a.issuer_name = b.issuer_name JOIN IssuerCounts ic ON a.issuer_name = ic.issuer_name WHERE a.security_id != b.security_id AND a.last_updated >= CURRENT_DATE - INTERVAL '30 days' AND b.last_updated < CURRENT_DATE - INTERVAL '90 days';

[User] Order the results by issuer name, then by the more recently updated security's ticker symbol.

[Assistant] WITH IssuerCounts AS (SELECT issuer_name, COUNT(*) AS total_securities FROM financial_services.securities WHERE issuer_name IS NOT NULL GROUP BY issuer_name HAVING COUNT(*) > 5) SELECT a.issuer_name, a.ticker_symbol AS ticker_symbol_a, a.last_updated AS last_updated_a, b.ticker_symbol AS ticker_symbol_b, b.last_updated AS last_updated_b FROM financial_services.securities AS a JOIN financial_services.securities AS b ON a.issuer_name = b.issuer_name JOIN IssuerCounts ic ON a.issuer_name = ic.issuer_name WHERE a.security_id != b.security_id AND a.last_updated >= CURRENT_DATE - INTERVAL '30 days' AND b.last_updated < CURRENT_DATE - INTERVAL '90 days' ORDER BY a.issuer_name ASC, a.ticker_symbol ASC;


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

[User] I need to find all pairs of diagnoses for the same patient where one diagnosis is chronic and the other is non-chronic. Show patient_id, chronic diagnosis_id as chronic_id, non-chronic diagnosis_id as acute_id, chronic diagnosis_date, and acute diagnosis_date.

[Assistant]
SELECT d1.patient_id,
       d1.diagnosis_id AS chronic_id,
       d2.diagnosis_id AS acute_id,
       d1.diagnosis_date AS chronic_date,
       d2.diagnosis_date AS acute_date
FROM healthcare.diagnoses d1
JOIN healthcare.diagnoses d2
  ON d1.patient_id = d2.patient_id
WHERE d1.is_chronic = TRUE
  AND d2.is_chronic = FALSE;

[User] Actually, only include pairs where the chronic diagnosis date is after the acute diagnosis date.

[Assistant]
SELECT d1.patient_id,
       d1.diagnosis_id AS chronic_id,
       d2.diagnosis_id AS acute_id,
       d1.diagnosis_date AS chronic_date,
       d2.diagnosis_date AS acute_date
FROM healthcare.diagnoses d1
JOIN healthcare.diagnoses d2
  ON d1.patient_id = d2.patient_id
WHERE d1.is_chronic = TRUE
  AND d2.is_chronic = FALSE
  AND d1.diagnosis_date > d2.diagnosis_date;

[User] Also restrict the results to diagnoses made in 2023.

[Assistant]
SELECT d1.patient_id,
       d1.diagnosis_id AS chronic_id,
       d2.diagnosis_id AS acute_id,
       d1.diagnosis_date AS chronic_date,
       d2.diagnosis_date AS acute_date
FROM healthcare.diagnoses d1
JOIN healthcare.diagnoses d2
  ON d1.patient_id = d2.patient_id
WHERE d1.is_chronic = TRUE
  AND d2.is_chronic = FALSE
  AND d1.diagnosis_date > d2.diagnosis_date
  AND d1.diagnosis_date BETWEEN '2023-01-01' AND '2023-12-31'
  AND d2.diagnosis_date BETWEEN '2023-01-01' AND '2023-12-31';


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.clients (
    client_id character varying(64) NOT NULL,  -- unique identifier for the client
    first_name character varying(100) NOT NULL, -- client's first name
    last_name character varying(100) NOT NULL, -- client's last name
    company_name character varying(200), -- company name if applicable
    email character varying(128) UNIQUE NOT NULL, -- client's primary email
    phone character varying(32), -- client's contact phone number
    address text, -- client's full address
    date_registered timestamp NOT NULL, -- when the client was first registered
    status character varying(32) NOT NULL, -- client status (e.g., active, inactive, prospect)
    PRIMARY KEY (client_id)
)
CREATE TABLE legal_services.time_entries (
    entry_id character varying(64) NOT NULL,  -- unique identifier for the time entry
    case_id character varying(64) NOT NULL, -- FK to cases table
    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table (who performed the work)
    date_worked date NOT NULL, -- date the work was performed
    hours_spent numeric(5, 2) NOT NULL CHECK (hours_spent > 0), -- duration of work in hours (e.g., 1.5 for 1h 30m)
    billing_rate numeric(10, 2) NOT NULL, -- hourly rate applied for this entry
    description text NOT NULL, -- detailed description of the work performed
    is_billable boolean DEFAULT true, -- whether this time entry is billable to the client
    is_billed boolean DEFAULT false, -- whether this entry has been included in an invoice
    invoice_id character varying(64), -- FK to invoices table (once billed)
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- when the entry was recorded
    PRIMARY KEY (entry_id)
)
CREATE TABLE legal_services.appointments (
    appointment_id character varying(64) NOT NULL, -- unique identifier for the appointment
    client_id character varying(64) NOT NULL, -- FK to clients table
    lawyer_id character varying(64) NOT NULL, -- FK to lawyers table
    case_id character varying(64), -- FK to cases table (optional, if related to a specific case)
    start_time timestamp NOT NULL, -- scheduled start date and time
    end_time timestamp NOT NULL, -- scheduled end date and time
    location text, -- location of the meeting (address or virtual link)
    subject character varying(255), -- subject or purpose of the appointment
    notes text, -- additional notes for the appointment
    status character varying(50) NOT NULL, -- e.g., Scheduled, Completed, Canceled, Rescheduled
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (appointment_id)
)

[User] Show me all appointments along with the subject, the appointment's start time, and the full name of the client associated with each appointment.

[Assistant] SELECT a.subject, a.start_time, c.first_name, c.last_name FROM legal_services.appointments AS a JOIN legal_services.clients AS c ON a.client_id = c.client_id;

[User] Only include appointments that are scheduled to start on or after '2024-08-01'.

[Assistant] SELECT a.subject, a.start_time, c.first_name, c.last_name FROM legal_services.appointments AS a JOIN legal_services.clients AS c ON a.client_id = c.client_id WHERE a.start_time >= '2024-08-01';

[User] Also, sort the results first by the client's last name in ascending order, and then by the appointment start time in descending order.

[Assistant] SELECT a.subject, a.start_time, c.first_name, c.last_name FROM legal_services.appointments AS a JOIN legal_services.clients AS c ON a.client_id = c.client_id WHERE a.start_time >= '2024-08-01' ORDER BY c.last_name ASC, a.start_time DESC;


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE legal_services.invoices ( invoice_id text PRIMARY KEY, invoice_number text UNIQUE, client_id text, case_id text, issue_date date, due_date date, total_amount numeric, amount_paid numeric, status text, payment_date timestamp, notes text, created_at timestamp )

[User] Show me pairs of invoice numbers for the same case.

[Assistant] SELECT T1.invoice_number, T2.invoice_number, T1.case_id FROM legal_services.invoices AS T1 JOIN legal_services.invoices AS T2 ON T1.case_id = T2.case_id AND T1.invoice_id <> T2.invoice_id ORDER BY T1.case_id, T1.invoice_number, T2.invoice_number

[User] Only include pairs where the total amount of one invoice is greater than the other.

[Assistant] SELECT T1.invoice_number, T2.invoice_number, T1.case_id, T1.total_amount AS invoice1_amount, T2.total_amount AS invoice2_amount FROM legal_services.invoices AS T1 JOIN legal_services.invoices AS T2 ON T1.case_id = T2.case_id AND T1.invoice_id <> T2.invoice_id WHERE T1.total_amount > T2.total_amount ORDER BY T1.case_id, invoice1_amount DESC

[User] Exclude pairs where the issue dates are more than 90 days apart.

[Assistant] SELECT T1.invoice_number, T2.invoice_number, T1.case_id, T1.total_amount AS invoice1_amount, T2.total_amount AS invoice2_amount, ABS(DATE_PART('day', T1.issue_date - T2.issue_date)) AS days_apart FROM legal_services.invoices AS T1 JOIN legal_services.invoices AS T2 ON T1.case_id = T2.case_id AND T1.invoice_id <> T2.invoice_id WHERE T1.total_amount > T2.total_amount AND ABS(DATE_PART('day', T1.issue_date - T2.issue_date)) <= 90 ORDER BY T1.case_id, days_apart ASC


System:
You are an expert in writing database language. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE transportation.drivers ( driver_id character varying(64) NOT NULL, employee_id character varying(64) NOT NULL UNIQUE, first_name character varying(128) NOT NULL, last_name character varying(128) NOT NULL, license_number character varying(64) NOT NULL UNIQUE, license_expiry_date date NOT NULL, contact_number character varying(32), email character varying(128) UNIQUE, hire_date date NOT NULL, status character varying(32) NOT NULL, PRIMARY KEY (driver_id) )
CREATE TABLE transportation.routes ( route_id character varying(64) NOT NULL, route_number character varying(32) NOT NULL UNIQUE, description text, origin_location_id character varying(64) NOT NULL, destination_location_id character varying(64) NOT NULL, distance_km numeric(10, 2), estimated_duration_minutes integer, type character varying(32) NOT NULL, PRIMARY KEY (route_id) )
CREATE TABLE transportation.locations ( location_id character varying(64) NOT NULL, name character varying(255) NOT NULL, type character varying(64) NOT NULL, address_line1 character varying(255), city character varying(128), state_province character varying(128), postal_code character varying(32), country character varying(64) NOT NULL, latitude numeric(9, 6), longitude numeric(9, 6), timezone character varying(64), PRIMARY KEY (location_id) )
CREATE TABLE transportation.passengers ( passenger_id character varying(64) NOT NULL, first_name character varying(128) NOT NULL, last_name character varying(128) NOT NULL, email character varying(128) UNIQUE, phone_number character varying(32) UNIQUE, date_of_birth date, loyalty_program_id character varying(64), created_at timestamp with time zone NOT NULL, PRIMARY KEY (passenger_id) )

[User] Could you provide the route number, the name of the origin location, and the name of the destination location for all routes?

[Assistant] SELECT T1.route_number ,  T2.name ,  T3.name FROM transportation.routes AS T1 JOIN transportation.locations AS T2 ON T1.origin_location_id  =  T2.location_id JOIN transportation.locations AS T3 ON T1.destination_location_id  =  T3.location_id

[User] Now, only show routes where the origin location is in the United States and the destination location is in Canada.

[Assistant] SELECT T1.route_number ,  T2.name ,  T3.name FROM transportation.routes AS T1 JOIN transportation.locations AS T2 ON T1.origin_location_id  =  T2.location_id JOIN transportation.locations AS T3 ON T1.destination_location_id  =  T3.location_id WHERE T2.country  =  'USA' AND T3.country  =  'Canada'


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.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 )

[User] How many drivers and passengers have email addresses ending with 'company.com'? Return the count for each group.

[Assistant]
SELECT 'drivers' AS role, COUNT(*) AS count
FROM transportation.drivers
WHERE email LIKE '%@company.com'
UNION ALL
SELECT 'passengers' AS role, COUNT(*) AS count
FROM transportation.passengers
WHERE email LIKE '%@company.com';

[User] Could you refine it further and only include active drivers in the result?

[Assistant]
SELECT 'drivers' AS role, COUNT(*) AS count
FROM transportation.drivers
WHERE email LIKE '%@company.com' AND status = 'Active'
UNION ALL
SELECT 'passengers' AS role, COUNT(*) AS count
FROM transportation.passengers
WHERE email LIKE '%@company.com';


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.applications ( application_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, service_id character varying(64) NOT NULL, submitted_at timestamp NOT NULL, status character varying(50) NOT NULL, last_updated_at timestamp NOT NULL, assigned_employee_id character varying(64), decision_date date, notes text, reference_number character varying(100) UNIQUE, PRIMARY KEY (application_id) )
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.employees ( employee_id character varying(64) NOT NULL, agency_id character varying(64) NOT NULL, first_name character varying(100) NOT NULL, last_name character varying(100) NOT NULL, job_title character varying(150) NOT NULL, department character varying(100), work_email character varying(128) NOT NULL UNIQUE, work_phone character varying(32), hire_date date NOT NULL, termination_date date, access_level character varying(50), manager_employee_id character varying(64), PRIMARY KEY (employee_id) )
CREATE TABLE government_services.appointments ( appointment_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, employee_id character varying(64), location_id character varying(64), service_id character varying(64), scheduled_start_time timestamp NOT NULL, scheduled_end_time timestamp, purpose text NOT NULL, status character varying(30) NOT NULL, booking_method character varying(50), created_at timestamp NOT NULL, notes text, PRIMARY KEY (appointment_id) )
CREATE TABLE government_services.notifications ( notification_id character varying(64) NOT NULL, citizen_id character varying(64) NOT NULL, application_id character varying(64), message_subject character varying(255), message_body text NOT NULL, channel character varying(30) NOT NULL, sent_at timestamp NOT NULL, status character varying(30) NOT NULL, related_entity_type character varying(50), related_entity_id character varying(64), PRIMARY KEY (notification_id) )

[User] Find the full names of employees who have verified documents that have an expiry date in the past and are marked as 'Verified'.

[Assistant] SELECT DISTINCT T1.first_name, T1.last_name FROM government_services.employees AS T1 JOIN government_services.documents AS T2 ON T1.employee_id = T2.verified_by_employee_id WHERE T2.expiry_date < CURRENT_DATE AND T2.verification_status = 'Verified'


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.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.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 )

[User] List all trips with their ID, vehicle ID, and driver ID.

[Assistant] SELECT trip_id, vehicle_id, driver_id FROM transportation.trips;

[User] Can you also include the scheduled departure and actual arrival times?

[Assistant] SELECT trip_id, vehicle_id, driver_id, scheduled_departure, actual_arrival FROM transportation.trips;

[User] Filter this to only show trips with status 'Completed'.

[Assistant] SELECT trip_id, vehicle_id, driver_id, scheduled_departure, actual_arrival FROM transportation.trips WHERE status = 'Completed';

[User] Order the results by actual arrival time in descending order.

[Assistant] SELECT trip_id, vehicle_id, driver_id, scheduled_departure, actual_arrival FROM transportation.trips WHERE status = 'Completed' ORDER BY actual_arrival 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 transportation.passengers (
    passenger_id character varying(64) NOT NULL,  -- unique identifier for the passenger
    first_name character varying(128) NOT NULL, -- passenger's first name
    last_name character varying(128) NOT NULL, -- passenger's last name
    email character varying(128) UNIQUE, -- email address
    phone_number character varying(32) UNIQUE, -- phone number
    date_of_birth date, -- passenger's date of birth
    loyalty_program_id character varying(64), -- identifier for loyalty program membership
    created_at timestamp with time zone NOT NULL, -- time when the passenger record was created
    PRIMARY KEY (passenger_id)
)
CREATE TABLE transportation.bookings ( booking_id character varying(64) NOT NULL, passenger_id character varying(64) NOT NULL, trip_id character varying(64) NOT NULL, seat_number character varying(16), booking_time timestamp with time zone NOT NULL, status character varying(32) NOT NULL, fare numeric(10, 2) NOT NULL, payment_transaction_id character varying(128), special_requests text, PRIMARY KEY (booking_id) )

[User] For each passenger, list their email along with the total amount spent on fares across all their bookings.

[Assistant]
SELECT p.passenger_id, p.email, SUM(b.fare) AS total_fare_spent
FROM transportation.passengers p
JOIN transportation.bookings b ON p.passenger_id = b.passenger_id
GROUP BY p.passenger_id, p.email;


System:
You are an expert in writing database language and you can refuse the user's question if the question is not related to the table structure. You can write a corresponding database language query to answer the user's question based on the table structure described by the table creation statement.
##Table Structure
CREATE TABLE manufacturing.employees (
    employee_id character varying(64) NOT NULL, -- unique identifier for the employee
    first_name character varying(100) NOT NULL,
    last_name character varying(100) NOT NULL,
    job_title character varying(128) NOT NULL, -- e.g., 'Aircraft Mechanic', 'Quality Inspector', 'Assembly Technician'
    skill_certifications text, -- comma-separated list or JSON of certifications
    hire_date date NOT NULL,
    assigned_line_id character varying(64), -- FK to the assembly line the employee is currently assigned to (can be null)
    employment_status character varying(50) NOT NULL, -- e.g., 'Active', 'On Leave', 'Terminated'
    supervisor_employee_id character varying(64), -- FK to the employee's supervisor (self-reference, nullable)
    PRIMARY KEY (employee_id)
)

[User] What is the current salary of employee with ID 'EMP123'?

[Assistant] I'm sorry, but I can't provide information about an employee's salary as it is not included in the data available in the 'employees' table.


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

[User] List all patients who have received a prescription with the route 'Topical', showing their ID, first name, and last name.

[Assistant]
SELECT DISTINCT
    p.patient_id,
    p.first_name,
    p.last_name
FROM
    healthcare.patients p
JOIN
    healthcare.prescriptions pr ON p.patient_id = pr.patient_id
WHERE
    pr.route = 'Topical';

[User] Only show patients who have received at least 2 such prescriptions.

[Assistant]
SELECT
    p.patient_id,
    p.first_name,
    p.last_name,
    COUNT(pr.prescription_id) AS topical_prescription_count
FROM
    healthcare.patients p
JOIN
    healthcare.prescriptions pr ON p.patient_id = pr.patient_id
WHERE
    pr.route = 'Topical'
GROUP BY
    p.patient_id, p.first_name, p.last_name
HAVING
    COUNT(pr.prescription_id) >= 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 financial_services.accounts ( account_id character varying(64) NOT NULL, customer_id character varying(64) NOT NULL, account_number character varying(128) NOT NULL UNIQUE, account_type character varying(50) NOT NULL, balance numeric(19, 4) NOT NULL DEFAULT 0.00, currency character varying(3) NOT NULL, opened_date date NOT NULL, status character varying(32) NOT NULL, interest_rate numeric(5, 4), last_updated_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (account_id), FOREIGN KEY (customer_id) REFERENCES financial_services.customers(customer_id) )

[User] What is the total balance for each currency in the accounts table?

[Assistant] SELECT currency, SUM(balance) AS total_balance FROM financial_services.accounts GROUP BY currency;

[User] Can you also show the number of accounts for each currency?

[Assistant] SELECT currency, COUNT(account_id) AS number_of_accounts, SUM(balance) AS total_balance FROM financial_services.accounts GROUP BY currency;

[User] Only include accounts with status 'ACTIVE' in the calculation.

[Assistant] SELECT currency, COUNT(account_id) AS number_of_accounts, SUM(balance) AS total_balance FROM financial_services.accounts WHERE status = 'ACTIVE' GROUP BY currency;