Sandbox Reference

Sandbox Schema & Relationships

A map of every table and column in the sandbox database — and how they connect. Read this before writing JOINs so you know exactly which column links to which table.

Practice in the Playground Start learning free

What am I looking at?

The sandbox is a PostgreSQL database with five pre-loaded datasets — e-commerce, finance, a chatbot log, maps, and health. Every lesson, the Playground, and the DBA tool all run queries against these exact tables. This page is your map: it shows every table, every column, and the relationships (foreign keys) that let you JOIN them together.

When you write a JOIN, you need to tell the database which column on table A matches which column on table B. Foreign keys are those columns. For example, orders.customer_id points to customers.id — so you join on that pair.

Legend

🔑 PKPrimary key — the unique identifier for each row in the table. Always id (or symbol in securities).
🔗 FKForeign key — this column “joins to” another table’s primary key. The badge shows the target (e.g. customers.id).
🔗 softText-match / soft link — a logical relationship (e.g. products.category matches categories.name) that is not an enforced database constraint. You can still join on it, but no referential integrity is guaranteed.

E-commerce

public

Products, customers, orders, line items, categories.

Relationship maporders.customer_id → customers.id

products

id🔑
category🔗
+4 more

customers

id🔑
+4 more

orders

id🔑
customer_id🔗
+2 more

order_items

id🔑
order_id🔗
product_id🔗
+2 more

How these tables join

orders.customer_id→customers.id
order_items.order_id→orders.id
order_items.product_id→products.id
products.category→categories.nametext match, not an enforced FK

Example JOIN

SELECT
  c.name        AS customer,
  o.placed_at,
  p.name        AS product,
  oi.quantity,
  oi.unit_price
FROM orders o
JOIN customers c       ON c.id        = o.customer_id
JOIN order_items oi    ON oi.order_id  = o.id
JOIN products p        ON p.id        = oi.product_id
WHERE o.status = 'shipped'
ORDER BY o.placed_at DESC
LIMIT 20;

Finance

finance

Customers, accounts, ~200k transactions, securities, holdings, trades.

Relationship mapaccounts.customer_id → customers.id

customers

id🔑
+6 more

accounts

id🔑
customer_id🔗
+5 more

transactions

id🔑
account_id🔗
+6 more

securities

symbol🔑
+4 more

holdings

account_id🔗
symbol🔗
+2 more

trades

id🔑
account_id🔗
symbol🔗
+4 more

foreign key soft linkfinance

finance.customers

id🔑 PK
name
email
country
kyc_status
risk_score
opened_at

finance.accounts

id🔑 PK
customer_id🔗 → finance.customers.id
account_type
currency
balance
is_active
opened_at

finance.transactions

id🔑 PK
account_id🔗 → finance.accounts.id
amount
kind
category
merchant_name
occurred_at
status

finance.securities

symbol🔑 PK
name
sector
exchange
ipo_date

finance.holdings

account_id🔗 → finance.accounts.id
symbol🔗 → finance.securities.symbol
quantity
avg_cost

finance.trades

id🔑 PK
account_id🔗 → finance.accounts.id
symbol🔗 → finance.securities.symbol
side
quantity
price
executed_at

How these tables join

accounts.customer_id→customers.id
transactions.account_id→accounts.id
holdings.account_id→accounts.id
holdings.symbol→securities.symbol
trades.account_id→accounts.id
trades.symbol→securities.symbol

Example JOIN

SELECT
  c.name          AS customer,
  a.account_type,
  a.currency,
  SUM(t.amount)   AS total_spent
FROM finance.accounts a
JOIN finance.customers c     ON c.id         = a.customer_id
JOIN finance.transactions t  ON t.account_id = a.id
WHERE t.kind = 'debit'
  AND t.occurred_at >= now() - interval '90 days'
GROUP BY c.name, a.account_type, a.currency
ORDER BY total_spent DESC
LIMIT 10;

Chatbot

chatbot

Users, conversations, ~200k messages, intents, feedback ratings.

Relationship mapconversations.user_id → users.id

users

id🔑
+4 more

intents

id🔑
+3 more

conversations

id🔑
user_id🔗
intent_id🔗
+4 more

messages

id🔑
conversation_id🔗
+5 more

feedback

id🔑
message_id🔗
user_id🔗
+4 more

foreign key soft linkchatbot

chatbot.users

id🔑 PK
email
display_name
plan
signed_up

chatbot.intents

id🔑 PK
name
category
description

chatbot.conversations

id🔑 PK
user_id🔗 → chatbot.users.id
intent_id🔗 → chatbot.intents.id
title
model
started_at
ended_at

chatbot.messages

id🔑 PK
conversation_id🔗 → chatbot.conversations.id
role
tokens_in
tokens_out
content_preview
created_at

chatbot.feedback

id🔑 PK
message_id🔗 → chatbot.messages.id
user_id🔗 → chatbot.users.id
rating
thumbs_up
comment
created_at

How these tables join

conversations.user_id→users.id
conversations.intent_id→intents.id
messages.conversation_id→conversations.id
feedback.message_id→messages.id
feedback.user_id→users.id

Example JOIN

SELECT
  u.display_name,
  i.name           AS intent,
  COUNT(m.id)      AS message_count,
  AVG(f.rating)    AS avg_rating
FROM chatbot.conversations cv
JOIN chatbot.users u     ON u.id              = cv.user_id
JOIN chatbot.intents i   ON i.id              = cv.intent_id
JOIN chatbot.messages m  ON m.conversation_id = cv.id
LEFT JOIN chatbot.feedback f ON f.message_id  = m.id
GROUP BY u.display_name, i.name
ORDER BY message_count DESC
LIMIT 10;

Maps

maps

Cities, 50k places (POIs), 200k reviews, users.

Relationship mapplaces.city_id → cities.id

cities

id🔑
+5 more

How these tables join

places.city_id→cities.id
reviews.place_id→places.id
reviews.user_id→users.id
places.category→categories.nametext match, not an enforced FK

Example JOIN

SELECT
  pl.name           AS place,
  ci.name           AS city,
  ROUND(AVG(r.rating)::numeric, 2) AS avg_rating,
  COUNT(r.id)       AS review_count
FROM maps.places pl
JOIN maps.cities ci    ON ci.id       = pl.city_id
JOIN maps.reviews r    ON r.place_id  = pl.id
GROUP BY pl.name, ci.name
HAVING COUNT(r.id) >= 5
ORDER BY avg_rating DESC
LIMIT 10;

Health

health

Hospitals, providers, patients, 100k visits, 60k prescriptions, 80k lab results. Synthetic only.

Relationship mapproviders.hospital_id → hospitals.id

hospitals

id🔑
+5 more

providers

id🔑
hospital_id🔗
+4 more

patients

id🔑
+6 more

visits

id🔑
patient_id🔗
provider_id🔗
+5 more

prescriptions

id🔑
visit_id🔗
+5 more

lab_results

id🔑
patient_id🔗
+7 more

foreign key soft linkhealth

health.hospitals

id🔑 PK
name
city
country
beds
type

health.providers

id🔑 PK
name
specialty
npi
hospital_id🔗 → health.hospitals.id
hired_at

health.patients

id🔑 PK
name
dob
sex
blood_type
country
registered_at

health.visits

id🔑 PK
patient_id🔗 → health.patients.id
provider_id🔗 → health.providers.id
visit_date
visit_type
primary_complaint
diagnosis_code
follow_up

health.prescriptions

id🔑 PK
visit_id🔗 → health.visits.id
drug_name
dosage
frequency
days_supply
prescribed_at

health.lab_results

id🔑 PK
patient_id🔗 → health.patients.id
test_name
result_value
unit
normal_low
normal_high
is_abnormal
taken_at

How these tables join

providers.hospital_id→hospitals.id
visits.patient_id→patients.id
visits.provider_id→providers.id
prescriptions.visit_id→visits.id
lab_results.patient_id→patients.id

Example JOIN

SELECT
  p.name           AS patient,
  v.visit_date,
  pr.name          AS provider,
  h.name           AS hospital,
  v.primary_complaint,
  v.diagnosis_code
FROM health.visits v
JOIN health.patients p    ON p.id          = v.patient_id
JOIN health.providers pr  ON pr.id         = v.provider_id
JOIN health.hospitals h   ON h.id          = pr.hospital_id
WHERE v.visit_date >= now() - interval '30 days'
ORDER BY v.visit_date DESC
LIMIT 10;

Ready to write your own JOINs?

Fire up the Playground and run a query against these tables, or start a lesson and practice with guided exercises.

Practice in the Playground Start learning free

What am I looking at?

Legend

🔑 PKPrimary key — the unique identifier for each row in the table. Always id (or symbol in securities).
🔗 FKForeign key — this column “joins to” another table’s primary key. The badge shows the target (e.g. customers.id).
🔗 softText-match / soft link — a logical relationship (e.g. products.category matches categories.name) that is not an enforced database constraint. You can still join on it, but no referential integrity is guaranteed.

SELECT c.name AS customer, o.placed_at, p.name AS product, oi.quantity, oi.unit_price FROM orders o JOIN customers c ON c.id = o.customer_id JOIN order_items oi ON oi.order_id = o.id JOIN products p ON p.id = oi.product_id WHERE o.status = 'shipped' ORDER BY o.placed_at DESC LIMIT 20;

SELECT c.name AS customer, a.account_type, a.currency, SUM(t.amount) AS total_spent FROM finance.accounts a JOIN finance.customers c ON c.id = a.customer_id JOIN finance.transactions t ON t.account_id = a.id WHERE t.kind = 'debit' AND t.occurred_at >= now() - interval '90 days' GROUP BY c.name, a.account_type, a.currency ORDER BY total_spent DESC LIMIT 10;

SELECT u.display_name, i.name AS intent, COUNT(m.id) AS message_count, AVG(f.rating) AS avg_rating FROM chatbot.conversations cv JOIN chatbot.users u ON u.id = cv.user_id JOIN chatbot.intents i ON i.id = cv.intent_id JOIN chatbot.messages m ON m.conversation_id = cv.id LEFT JOIN chatbot.feedback f ON f.message_id = m.id GROUP BY u.display_name, i.name ORDER BY message_count DESC LIMIT 10;

SELECT pl.name AS place, ci.name AS city, ROUND(AVG(r.rating)::numeric, 2) AS avg_rating, COUNT(r.id) AS review_count FROM maps.places pl JOIN maps.cities ci ON ci.id = pl.city_id JOIN maps.reviews r ON r.place_id = pl.id GROUP BY pl.name, ci.name HAVING COUNT(r.id) >= 5 ORDER BY avg_rating DESC LIMIT 10;

SELECT p.name AS patient, v.visit_date, pr.name AS provider, h.name AS hospital, v.primary_complaint, v.diagnosis_code FROM health.visits v JOIN health.patients p ON p.id = v.patient_id JOIN health.providers pr ON pr.id = v.provider_id JOIN health.hospitals h ON h.id = pr.hospital_id WHERE v.visit_date >= now() - interval '30 days' ORDER BY v.visit_date DESC LIMIT 10;