prepravljena data mart sema i generator jebemliga

docs
nifi flow
2026-05-19 15:46:11 +02:00 · 2026-05-17 21:27:42 +02:00 · 2026-05-17 21:24:37 +02:00 · 2026-05-17 21:23:55 +02:00 · 2026-05-17 21:21:43 +02:00 · 2026-05-17 20:56:31 +02:00
14 changed files with 2216 additions and 9 deletions
--- a/docker/start.ps1
+++ b/docker/start.ps1
@@ -1,9 +1,9 @@
 $ErrorActionPreference = "Stop"
-$CONTAINER = "ewc2025-mysql"
+$CONTAINER = "hotel-mysql"
 $IMAGE     = "mysql:8.4"
-$ROOT_PASSWORD = "ewc2025root"
+$ROOT_PASSWORD = "hotel2025root"
-$DATABASE  = "ewc2025"
+$DATABASE  = "hotel_reservations"
 $PORT      = "13306"
 $SQL_DIR = Resolve-Path "$PSScriptRoot\..\sql"
--- a/docker/start.sh
+++ b/docker/start.sh
@@ -1,10 +1,10 @@
 #!/usr/bin/env bash
 set -euo pipefail
-CONTAINER="ewc2025-mysql"
+CONTAINER="hotel-mysql"
 IMAGE="mysql:8.4"
-ROOT_PASSWORD="ewc2025root"
+ROOT_PASSWORD="hotel2025root"
-DATABASE="ewc2025"
+DATABASE="hotel_reservations"
 PORT="13306"
 RUNTIME="docker"
@@ -26,7 +26,7 @@ else
        -e MYSQL_DATABASE="${DATABASE}" \
        -p "${PORT}:3306" \
        -v "${CONTAINER}-data:/var/lib/mysql" \
-        -v "${SQL_DIR}/schema.sql:/docker-entrypoint-initdb.d/01_schema.sql:ro" \
+        -v "${SQL_DIR}/schema.sql:/docker-entrypoint-initdb.d/01_schema.sql:ro,z" \
        "${IMAGE}"
 fi
--- a/docker/stop.ps1
+++ b/docker/stop.ps1
@@ -1,6 +1,6 @@
 $ErrorActionPreference = "Stop"
-$CONTAINER = "ewc2025-mysql"
+$CONTAINER = "hotel-mysql"
 $exists = docker ps -a --format '{{.Names}}' | Where-Object { $_ -eq $CONTAINER }
--- a/docker/stop.sh
+++ b/docker/stop.sh
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
-CONTAINER="ewc2025-mysql"
+CONTAINER="hotel-mysql"
 RUNTIME="docker"
 if [[ "${1:-}" == "--podman" ]]; then
--- a/docs/01-overview.md
+++ b/docs/01-overview.md
@@ -0,0 +1,98 @@
 # Hotel Reservations — Data Warehouse Project
 ## Project Summary
 This project implements a complete **Data Warehousing pipeline** for a hotel reservation system, covering all standard DW layers:
 ```
 MySQL OLTP  ──►  Apache NiFi ETL  ──►  Oracle Data Mart  ──►  Power BI Reports
 (source)          (transform)           (analytical store)      (OLAP queries)
 ```
 The system is built around the **A.24 Hotel Reservations** domain from the course specification. The OLTP database was populated with **~635,000 synthetically generated rows** covering 200 hotels, 100,000 guests, 500,000 bookings, and 531,000 room bookings across a 4-year period (2022–2025).
 ---
 ## Business Context
 A hotel chain needs to answer questions like:
 - Which countries generate the most revenue per quarter?
 - How does occupancy differ between peak and off-peak seasons?
 - What is the revenue contribution of 5-star vs 3-star hotels?
 - How has a hotel's revenue changed after upgrading its star rating?
 These questions require **historical, multi-dimensional analysis** that a normalized OLTP database cannot serve efficiently. The data mart provides pre-modelled, denormalized data optimized for analytical queries.
 ---
 ## Architecture
 ```
 ┌─────────────────────────────────────────────────────────┐
 │  SOURCE LAYER                                           │
 │  MySQL 8.4  (Docker/Podman, port 13306)                 │
 │  Database: hotel_reservations                           │
 │  13 normalized tables, ~635K rows                       │
 └───────────────────────┬─────────────────────────────────┘
                        │ JDBC (MySqlConnector)
                        ▼
 ┌─────────────────────────────────────────────────────────┐
 │  ETL LAYER                                              │
 │  Apache NiFi                                            │
 │  5 Process Groups: Date Dim / Static Dims /             │
 │  SCD2 Hotel / SCD1 Guest / Incremental Fact             │
 └───────────────────────┬─────────────────────────────────┘
                        │ JDBC (Oracle JDBC)
                        ▼
 ┌─────────────────────────────────────────────────────────┐
 │  DATA MART LAYER                                        │
 │  Oracle (university lab schema)                         │
 │  Star schema: 6 dimensions + 1 fact table               │
 │  SCD Type 2 on DIM_HOTEL                                │
 └───────────────────────┬─────────────────────────────────┘
                        │
                        ▼
 ┌─────────────────────────────────────────────────────────┐
 │  PRESENTATION LAYER                                     │
 │  Power BI Desktop                                       │
 │  OLAP reports via DirectQuery / Import                  │
 └─────────────────────────────────────────────────────────┘
 ```
 ---
 ## Technology Stack
 | Component | Technology | Version |
 |-----------|-----------|---------|
 | OLTP Database | MySQL | 8.4 |
 | Container runtime | Docker / Podman | — |
 | Data generator | C# (.NET) | 10 |
 | ETL tool | Apache NiFi | — |
 | Data Mart | Oracle RDBMS | university lab |
 | Reporting | Power BI Desktop | — |
 ---
 ## Repository Structure
 ```
 IPZ_1/
 ├── docker/
 │   ├── start.sh          # Start MySQL container (Linux/macOS)
 │   ├── stop.sh           # Stop MySQL container
 │   ├── start.ps1         # Start MySQL container (Windows)
 │   └── stop.ps1          # Stop MySQL container
 ├── sql/
 │   ├── schema.sql        # MySQL OLTP DDL
 │   └── datamart_schema.sql  # Oracle Data Mart DDL
 ├── generator/
 │   └── generate.cs       # .NET 10 data generator script
 └── docs/
    ├── 01-overview.md    # This file
    ├── 02-oltp.md        # OLTP database design
    ├── 03-datamart.md    # Data mart design
    ├── 04-setup.md       # Setup and run guide
    └── nifi-flow.md      # NiFi ETL flow reference
 ```
--- a/docs/02-oltp.md
+++ b/docs/02-oltp.md
@@ -0,0 +1,258 @@
 # OLTP Database — Design & Details
 ## Overview
 The OLTP (Online Transaction Processing) database models a **hotel reservation system** using a fully normalized relational schema in **MySQL 8.4**. It follows 3NF and enforces referential integrity via foreign keys.
 - **Database:** `hotel_reservations`
 - **Character set:** `utf8mb4` / `utf8mb4_unicode_ci`
 - **Tables:** 13
 - **Total rows:** ~635,000
 ---
 ## Entity-Relationship Model
 The schema covers five entity groups:
 ```
 hotel_chain ──┐
 country ───────┼──► hotel ──► hotel_room ──► room_booking ──► booking ──► guest
 star_rating ──┘                                                            │
                                                                           └──► country
 hotel_characteristic ◄──► hotel (M:N via hotel_hotel_characteristic)
 room_type ◄──── hotel_room
 room_type ◄──┐
 rate_period ◄─┴── period_room_rate  (price per room type per season)
 ```
 ---
 ## Table Descriptions
 ### Reference / Lookup Tables
 #### `hotel_chain`
 International hotel chains (Hilton, Marriott, Accor, etc.).
 | Column | Type | Description |
 |--------|------|-------------|
 | `hotel_chain_id` | INT UNSIGNED PK | Surrogate key |
 | `code` | VARCHAR(10) UNIQUE | Short code (e.g. `HLT`) |
 | `name` | VARCHAR(100) | Full name |
 **Rows:** 10
 ---
 #### `country`
 Countries from which guests come and where hotels are located.
 | Column | Type | Description |
 |--------|------|-------------|
 | `country_id` | INT UNSIGNED PK | Surrogate key |
 | `code` | CHAR(2) UNIQUE | ISO 3166-1 alpha-2 (e.g. `GB`) |
 | `name` | VARCHAR(100) | Country name |
 | `currency` | VARCHAR(10) | ISO currency code (e.g. `EUR`) |
 **Rows:** 40 (Europe, Americas, Asia, Africa, Oceania)
 ---
 #### `star_rating`
 Hotel classification from 1★ to 5★.
 | Column | Type | Description |
 |--------|------|-------------|
 | `star_rating_id` | INT UNSIGNED PK | Surrogate key |
 | `code` | TINYINT UNIQUE | 1–5 |
 | `description` | VARCHAR(20) | e.g. `3 Star` |
 **Rows:** 5
 ---
 #### `hotel_characteristic`
 Amenities and features a hotel may offer.
 | Column | Type | Description |
 |--------|------|-------------|
 | `characteristic_id` | INT UNSIGNED PK | Surrogate key |
 | `code` | VARCHAR(20) UNIQUE | e.g. `POOL`, `SPA`, `WIFI` |
 | `description` | VARCHAR(100) | Human-readable label |
 **Rows:** 12 (WiFi, Pool, Gym, Spa, Restaurant, Bar, Parking, Valet, Conference, Shuttle, Room Service, Pet Friendly)
 ---
 #### `room_type`
 Types of rooms a hotel can offer, with a standard (base) rate.
 | Column | Type | Description |
 |--------|------|-------------|
 | `room_type_id` | INT UNSIGNED PK | Surrogate key |
 | `code` | VARCHAR(20) UNIQUE | e.g. `SINGLE`, `SUITE` |
 | `description` | VARCHAR(100) | e.g. `Junior Suite` |
 | `standard_rate` | DECIMAL(10,2) | Base nightly rate (EUR) |
 | `smoking_yn` | BOOLEAN | Smoking allowed flag |
 **Rows:** 7 (Single €80, Double €120, Twin €115, Deluxe €180, Suite €280, Executive €450, Family €200)
 ---
 #### `rate_period`
 Seasonal pricing periods. Each period maps to a month range and applies a rate multiplier.
 | Column | Type | Description |
 |--------|------|-------------|
 | `rate_period_id` | INT UNSIGNED PK | Surrogate key |
 | `code` | VARCHAR(20) UNIQUE | e.g. `PEAK`, `WINTER` |
 | `description` | VARCHAR(50) | Human-readable label |
 | `month_from` | TINYINT | Start month (1–12) |
 | `month_to` | TINYINT | End month (1–12) |
 **Rows:** 4
 | Code | Period | Months | Multiplier |
 |------|--------|--------|-----------|
 | PEAK | Peak Season | Jun–Aug | ×1.5 |
 | HIGH | High Season | Mar–May | ×1.2 |
 | AUTUMN | Autumn Season | Sep–Nov | ×1.1 |
 | WINTER | Winter Season | Dec–Feb | ×0.9 |
 ---
 ### Junction Tables
 #### `period_room_rate`
 The effective nightly rate for each (room_type, rate_period) combination.  
 Rate = `standard_rate × season_multiplier`.
 | Column | Type | Description |
 |--------|------|-------------|
 | `room_type_id` | INT UNSIGNED PK/FK | |
 | `rate_period_id` | INT UNSIGNED PK/FK | |
 | `rate` | DECIMAL(10,2) | Effective nightly rate |
 **Rows:** 28 (7 room types × 4 seasons)
 ---
 #### `hotel_hotel_characteristic`
 M:N junction between hotels and their amenities.
 | Column | Type |
 |--------|------|
 | `hotel_id` | INT UNSIGNED PK/FK |
 | `characteristic_id` | INT UNSIGNED PK/FK |
 **Rows:** ~1,415
 ---
 ### Core Entity Tables
 #### `hotel`
 Individual hotel properties.
 | Column | Type | Description |
 |--------|------|-------------|
 | `hotel_id` | INT UNSIGNED PK | |
 | `hotel_chain_id` | INT UNSIGNED FK | NULL for independent hotels |
 | `country_id` | INT UNSIGNED FK | |
 | `star_rating_id` | INT UNSIGNED FK | |
 | `code` | VARCHAR(20) UNIQUE | e.g. `HTL0001` |
 | `name` | VARCHAR(150) | |
 | `address` | VARCHAR(200) | |
 | `postcode` | VARCHAR(20) | |
 | `city` | VARCHAR(100) | |
 | `url` | VARCHAR(200) | |
 **Rows:** 200 (50 cities, star distribution: 5% 1★, 10% 2★, 40% 3★, 30% 4★, 15% 5★)
 ---
 #### `hotel_room`
 Individual rooms within each hotel.
 | Column | Type | Description |
 |--------|------|-------------|
 | `room_id` | INT UNSIGNED PK | |
 | `hotel_id` | INT UNSIGNED FK | |
 | `room_type_id` | INT UNSIGNED FK | |
 | `room_number` | VARCHAR(10) | Format: `{floor}{number}`, e.g. `101` |
 | `floor` | TINYINT UNSIGNED | |
 **Rows:** 5,334 (5–60 rooms per hotel depending on star rating)
 ---
 #### `guest`
 Hotel guests.
 | Column | Type | Description |
 |--------|------|-------------|
 | `guest_id` | INT UNSIGNED PK | |
 | `country_id` | INT UNSIGNED FK | Guest's home country |
 | `name` | VARCHAR(150) | Full name |
 | `email` | VARCHAR(150) | Unique synthetic email |
 | `address` | VARCHAR(200) | |
 | `city` | VARCHAR(100) | |
 **Rows:** 100,000
 ---
 #### `booking`
 A reservation made by a guest at a hotel. One booking can cover multiple rooms.
 | Column | Type | Description |
 |--------|------|-------------|
 | `booking_id` | INT UNSIGNED PK | |
 | `guest_id` | INT UNSIGNED FK | |
 | `hotel_id` | INT UNSIGNED FK | |
 | `date_from` | DATE | Check-in |
 | `date_to` | DATE | Check-out |
 | `status` | ENUM | `confirmed`, `cancelled`, `completed`, `no_show` |
 | `created_at` | DATETIME | When booking was made |
 **Rows:** 500,000  
 **Status distribution:** 80% completed, 10% confirmed, 7% cancelled, 3% no_show  
 **Date range:** 2022-01-01 – 2025-12-31  
 **Seasonal distribution:** June–August heaviest (peak), December–February lightest
 ---
 #### `room_booking`
 A specific room assigned within a booking. Stores the rate **as it was at booking time** (snapshot), independent of any future rate changes.
 | Column | Type | Description |
 |--------|------|-------------|
 | `room_booking_id` | INT UNSIGNED PK | |
 | `booking_id` | INT UNSIGNED FK | |
 | `room_id` | INT UNSIGNED FK | |
 | `date_from` | DATE | |
 | `date_to` | DATE | |
 | `nightly_rate` | DECIMAL(10,2) | Rate at time of booking |
 | `total_amount` | DECIMAL(10,2) | `nightly_rate × nights` |
 **Rows:** 531,382  
 **Room count per booking:** 90% single room, 8% two rooms, 2% three rooms
 ---
 ## Data Generation
 The database was populated using a **single-file C# script** (`generator/generate.cs`) running on .NET 10, using `MySqlConnector` as the only dependency.
 Key generation decisions:
 - **Seasonal booking distribution** via rejection sampling — months Jun–Aug are ~2.7× more likely than Jan–Feb
 - **Rate snapshot** — each `room_booking.nightly_rate` is looked up from `period_room_rate` at insert time and stored, not re-computed later
 - **Realistic stay lengths** — 30% one night, 25% two nights, 20% three nights, tapering off to 14-night stays
 - **Cancelled/no-show bookings** partially skip room assignment (60% of cancellations have no room_booking)
 ```bash
 # Run generator
 dotnet run generator/generate.cs
 ```
--- a/docs/03-datamart.md
+++ b/docs/03-datamart.md
@@ -0,0 +1,255 @@
 # Data Mart — Design & Details
 ## Overview
 The data mart uses a **star schema** stored in an Oracle database (university lab schema). It is optimized for analytical queries against hotel reservation data — revenue analysis, occupancy trends, seasonal patterns, and guest origin breakdowns.
 - **Schema type:** Star schema
 - **Dimensions:** 6 (+ date dimension)
 - **Fact table:** `FACT_ROOM_BOOKING`
 - **Grain:** One row per room_booking (one room, one stay)
 - **SCD strategy:** Type 2 on DIM_HOTEL, Type 1 on all others
 ---
 ## Star Schema Diagram
 ```
                        DIM_DATE
                       (date_key)
                           │
               ┌───────────┴───────────┐
               │ checkin / checkout    │
               │                       │
 DIM_HOTEL_CHAIN ◄─ DIM_HOTEL ─► DIM_STAR_RATING
       │               │
       │      FACT_ROOM_BOOKING ◄──── DIM_ROOM
       │               │
       └───────►   DIM_COUNTRY ◄───── DIM_GUEST
 ```
 ---
 ## Dimension Tables
 ### DIM_DATE
 Populated once for the range 2020–2030. Used for both check-in and check-out date lookups.
 | Column | Type | Description |
 |--------|------|-------------|
 | `date_key` | NUMBER(8) PK | YYYYMMDD integer key |
 | `full_date` | DATE | Actual date value |
 | `year` | NUMBER(4) | |
 | `quarter` | NUMBER(1) | 1–4 |
 | `month` | NUMBER(2) | 1–12 |
 | `month_name` | VARCHAR2(10) | e.g. `January` |
 | `week_number` | NUMBER(2) | ISO week number |
 | `day_of_month` | NUMBER(2) | |
 | `day_name` | VARCHAR2(10) | e.g. `Monday` |
 | `is_weekend` | NUMBER(1) | 0/1 |
 | `is_business_day` | NUMBER(1) | 0/1 |
 | `season` | VARCHAR2(10) | Peak / High / Autumn / Winter |
 Using an integer date key (YYYYMMDD) instead of a DATE FK allows efficient range predicates: `checkin_date_key BETWEEN 20240601 AND 20240831`.
 ---
 ### DIM_COUNTRY (SCD Type 1)
 Country attributes are stable. If a name or currency ever changes, the row is simply overwritten (no history needed).
 | Column | Type | Description |
 |--------|------|-------------|
 | `country_key` | NUMBER(10) PK | Surrogate (IDENTITY) |
 | `country_id` | NUMBER(10) UNIQUE | Natural key from MySQL |
 | `code` | CHAR(2) | ISO alpha-2 |
 | `name` | VARCHAR2(100) | |
 | `currency` | VARCHAR2(10) | ISO currency code |
 ---
 ### DIM_STAR_RATING (SCD Type 1)
 Static lookup. Star rating codes 1–5 never change.
 | Column | Type | Description |
 |--------|------|-------------|
 | `star_rating_key` | NUMBER(10) PK | Surrogate (IDENTITY) |
 | `star_rating_id` | NUMBER(10) UNIQUE | Natural key |
 | `code` | NUMBER(1) | 1–5 |
 | `description` | VARCHAR2(20) | e.g. `4 Star` |
 ---
 ### DIM_HOTEL_CHAIN (SCD Type 1)
 Chain name/code may be updated (e.g. corporate rebranding), but we do not need a historical record of chain name changes.
 | Column | Type | Description |
 |--------|------|-------------|
 | `hotel_chain_key` | NUMBER(10) PK | Surrogate (IDENTITY) |
 | `hotel_chain_id` | NUMBER(10) UNIQUE | Natural key |
 | `code` | VARCHAR2(10) | e.g. `HLT` |
 | `name` | VARCHAR2(100) | |
 ---
 ### DIM_HOTEL (SCD Type 2)
 This is the most analytically significant dimension and the only one implemented as **Slowly Changing Dimension Type 2**.
 **Why SCD Type 2 here?**
 A hotel's star rating or chain affiliation can change over time — a property gets renovated and reclassified from 3★ to 4★, or switches from one international chain to another. These changes directly affect revenue analysis: a 3★ hotel charges different rates than a 4★ hotel, and grouping all historical bookings under the current star rating would produce misleading averages.
 SCD Type 2 preserves history by creating a **new row** for each version of a hotel, while expiring the old row with an `expiry_date`. The fact table's `hotel_key` always points to the version that was active **at check-in date**, never to the current version if it changed.
 | Column | Type | Description |
 |--------|------|-------------|
 | `hotel_key` | NUMBER(10) PK | Surrogate (IDENTITY) |
 | `source_hotel_id` | NUMBER(10) | Natural key from MySQL |
 | `hotel_chain_key` | NUMBER(10) FK | NULL for independent hotels |
 | `country_key` | NUMBER(10) FK | |
 | `star_rating_key` | NUMBER(10) FK | |
 | `code` | VARCHAR2(20) | |
 | `name` | VARCHAR2(150) | |
 | `city` | VARCHAR2(100) | |
 | `effective_date` | DATE | When this version became active |
 | `expiry_date` | DATE | When this version was superseded (NULL = current) |
 | `is_current` | NUMBER(1) | 1 = current version |
 **SCD2 example:**
 | hotel_key | source_hotel_id | star_rating | effective_date | expiry_date | is_current |
 |-----------|----------------|-------------|----------------|-------------|-----------|
 | 1 | 42 | 3★ | 2022-01-01 | 2024-05-31 | 0 |
 | 2 | 42 | 4★ | 2024-06-01 | NULL | 1 |
 Bookings from 2022–2024 point to `hotel_key=1`, bookings from 2024 onward point to `hotel_key=2`. Revenue by star category remains historically correct.
 ---
 ### DIM_ROOM (SCD Type 1)
 Room type is stable for our dataset. Updated via MERGE if room details ever change.
 | Column | Type | Description |
 |--------|------|-------------|
 | `room_key` | NUMBER(10) PK | Surrogate (IDENTITY) |
 | `room_id` | NUMBER(10) UNIQUE | Natural key |
 | `hotel_key` | NUMBER(10) FK | Points to current DIM_HOTEL version |
 | `room_number` | VARCHAR2(10) | |
 | `floor` | NUMBER(3) | |
 | `room_type_code` | VARCHAR2(20) | e.g. `SUITE` |
 | `room_type_desc` | VARCHAR2(100) | |
 | `smoking_yn` | NUMBER(1) | |
 | `standard_rate` | NUMBER(10,2) | Base rate from OLTP |
 ---
 ### DIM_GUEST (SCD Type 1)
 Guest personal data (city, country) may change, but tracking historical addresses has no analytical value for this domain. MERGE (upsert) is used.
 | Column | Type | Description |
 |--------|------|-------------|
 | `guest_key` | NUMBER(10) PK | Surrogate (IDENTITY) |
 | `guest_id` | NUMBER(10) UNIQUE | Natural key |
 | `country_key` | NUMBER(10) FK | Home country |
 | `name` | VARCHAR2(150) | |
 | `city` | VARCHAR2(100) | |
 ---
 ## Fact Table: FACT_ROOM_BOOKING
 **Grain:** One row per room_booking — one specific room, for one stay.
 | Column | Type | Description |
 |--------|------|-------------|
 | `fact_id` | NUMBER(10) PK | Surrogate (IDENTITY) |
 | `source_rb_id` | NUMBER(10) UNIQUE | Natural key — used for idempotent incremental loads |
 | `hotel_key` | NUMBER(10) FK | SCD2-resolved hotel version at check-in |
 | `hotel_chain_key` | NUMBER(10) FK | Denormalized from DIM_HOTEL for convenience |
 | `room_key` | NUMBER(10) FK | |
 | `guest_key` | NUMBER(10) FK | |
 | `country_key` | NUMBER(10) FK | Guest's country — denormalized |
 | `star_rating_key` | NUMBER(10) FK | Denormalized from DIM_HOTEL for convenience |
 | `checkin_date_key` | NUMBER(8) FK | YYYYMMDD |
 | `checkout_date_key` | NUMBER(8) FK | YYYYMMDD |
 | `booking_status` | VARCHAR2(20) | Degenerate dimension: confirmed/completed/cancelled/no_show |
 | `nights_stayed` | NUMBER(4) | checkout − checkin in days |
 | `nightly_rate` | NUMBER(10,2) | Rate per night at time of booking |
 | `total_amount` | NUMBER(12,2) | `nightly_rate × nights_stayed` |
 ### Measures
 | Measure | Type | Aggregation |
 |---------|------|-------------|
 | `nights_stayed` | Additive | SUM, AVG |
 | `nightly_rate` | Semi-additive | AVG (not SUM — rate doesn't add across rooms meaningfully) |
 | `total_amount` | Additive | SUM (main revenue measure) |
 ### Degenerate Dimensions
 `booking_status` is stored directly on the fact row. Splitting it into a separate dimension table would add a table with only 4 rows and no other attributes — not worth the JOIN overhead.
 ---
 ## ETL Control Tables
 ### ETL_WATERMARK
 Tracks the highest `room_booking_id` already loaded into the fact table, enabling incremental loads without re-reading the entire source.
 | Column | Description |
 |--------|-------------|
 | `entity_name` | Logical entity name (e.g. `FACT_ROOM_BOOKING`) |
 | `last_key` | Highest PK value loaded so far |
 | `last_run_ts` | Timestamp of the last ETL run |
 ### STG_HOTEL
 Staging table used by the SCD2 ETL process. NiFi loads raw hotel data from MySQL here, then SQL applies the expire-and-insert SCD2 logic in a single transaction. Truncated at the start of each ETL run.
 ---
 ## Sample Analytical Queries
 ### Revenue by country and quarter
 ```sql
 SELECT
    c.name          AS country,
    d.year,
    d.quarter,
    SUM(f.total_amount)     AS revenue,
    COUNT(*)                AS room_nights
 FROM FACT_ROOM_BOOKING f
 JOIN DIM_DATE    d ON d.date_key    = f.checkin_date_key
 JOIN DIM_GUEST   g ON g.guest_key  = f.guest_key
 JOIN DIM_COUNTRY c ON c.country_key = g.country_key
 WHERE f.booking_status = 'completed'
 GROUP BY c.name, d.year, d.quarter
 ORDER BY revenue DESC;
 ```
 ### Average revenue per star category (correct because of SCD2)
 ```sql
 SELECT
    sr.code         AS stars,
    d.season,
    AVG(f.nightly_rate)     AS avg_nightly_rate,
    SUM(f.total_amount)     AS total_revenue
 FROM FACT_ROOM_BOOKING f
 JOIN DIM_HOTEL       h  ON h.hotel_key       = f.hotel_key
 JOIN DIM_STAR_RATING sr ON sr.star_rating_key = f.star_rating_key
 JOIN DIM_DATE        d  ON d.date_key         = f.checkin_date_key
 GROUP BY sr.code, d.season
 ORDER BY sr.code, d.season;
 ```
 ### Top 10 cities by occupancy (room-nights)
 ```sql
 SELECT
    h.city,
    SUM(f.nights_stayed)   AS room_nights,
    SUM(f.total_amount)    AS revenue
 FROM FACT_ROOM_BOOKING f
 JOIN DIM_HOTEL h ON h.hotel_key = f.hotel_key
 WHERE f.booking_status IN ('completed','confirmed')
 GROUP BY h.city
 ORDER BY room_nights DESC
 FETCH FIRST 10 ROWS ONLY;
 ```
--- a/docs/04-setup.md
+++ b/docs/04-setup.md
@@ -0,0 +1,181 @@
 # Setup Guide
 ## Prerequisites
 | Tool | Required for | Notes |
 |------|-------------|-------|
 | Docker or Podman | MySQL container | Use `--podman` flag on Linux |
 | .NET 10 SDK | Data generator | `dotnet run file.cs` support |
 | Apache NiFi | ETL | Running instance with Oracle + MySQL JDBC drivers |
 | Oracle JDBC driver | NiFi | `ojdbc11.jar` in NiFi's lib directory |
 | MySQL JDBC driver | NiFi | `mysql-connector-j-*.jar` in NiFi's lib directory |
 | Oracle DB access | Data mart target | University lab credentials |
 ---
 ## Step 1 — Start MySQL Container
 **Linux / macOS (Docker):**
 ```bash
 bash docker/start.sh
 ```
 **Linux / macOS (Podman):**
 ```bash
 bash docker/start.sh --podman
 ```
 **Windows (PowerShell):**
 ```powershell
 .\docker\start.ps1
 ```
 The script:
 - Creates a named container `hotel-mysql` with a persistent data volume
 - Mounts `sql/schema.sql` as an init script — all 13 tables are created automatically on first start
 - Waits until MySQL is ready before exiting
 **Connection details:**
 ```
 Host:     127.0.0.1
 Port:     13306
 Database: hotel_reservations
 User:     root
 Password: hotel2025root
 ```
 ---
 ## Step 2 — Generate OLTP Data
 ```bash
 dotnet run generator/generate.cs
 ```
 **Runtime:** ~3 minutes  
 **Output:** 635,000+ rows across 13 tables
 The generator is deterministic (fixed seed `42`) — running it twice on an empty database produces the same data.
 > **Important:** Run the generator only once on an empty database. If you need to restart, truncate all tables first (respecting FK order) or drop and recreate the container + volume.
 ### Quick table verification after generation:
 ```bash
 # Docker
 docker exec hotel-mysql mysql -uroot -photel2025root hotel_reservations \
  -e "SELECT table_name, table_rows FROM information_schema.tables WHERE table_schema='hotel_reservations';"
 # Podman
 podman exec hotel-mysql mysql -uroot -photel2025root hotel_reservations \
  -e "SELECT table_name, table_rows FROM information_schema.tables WHERE table_schema='hotel_reservations';"
 ```
 ---
 ## Step 3 — Prepare Oracle Data Mart
 Connect to the Oracle schema (university lab) and execute `sql/datamart_schema.sql`.
 The script creates:
 - `ETL_WATERMARK` (with initial row for `FACT_ROOM_BOOKING`)
 - `STG_HOTEL` (staging)
 - All 7 dimension tables
 - `FACT_ROOM_BOOKING`
 ```sql
 -- Run in SQL*Plus or SQL Developer:
@datamart_schema.sql
 ```
 ---
 ## Step 4 — Configure NiFi
 ### 4.1 Add JDBC drivers to NiFi
 Copy the following JARs to `$NIFI_HOME/lib/` (or the NiFi extensions directory):
 - `mysql-connector-j-8.x.jar`
 - `ojdbc11.jar`
 Restart NiFi after adding drivers.
 ### 4.2 Create Controller Services
 In NiFi UI → Controller Settings → Controller Services:
 **MySQL connection:**
 - Type: `DBCPConnectionPool`
 - Database Driver Class Name: `com.mysql.cj.jdbc.Driver`
 - Database Connection URL: `jdbc:mysql://127.0.0.1:13306/hotel_reservations`
 - Database User: `root`
 - Password: `hotel2025root`
 **Oracle connection:**
 - Type: `DBCPConnectionPool`
 - Database Driver Class Name: `oracle.jdbc.OracleDriver`
 - Database Connection URL: `jdbc:oracle:thin:@<host>:1521:<sid>`
 - Database User: `<your_schema>`
 - Password: `<your_password>`
 Enable both services.
 ### 4.3 Build Process Groups
 Follow the detailed processor configuration in `docs/nifi-flow.md`.
 **Recommended build order:**
 1. PG-1: Date Dimension (simplest, test first)
 2. PG-2: Static Dimensions (verify MERGE logic)
 3. PG-3: DIM_HOTEL SCD2 (most complex — check staging table after run)
 4. PG-4: DIM_GUEST SCD1
 5. PG-5: Fact Incremental Load
 ---
 ## Step 5 — Run ETL
 ### First full load
 1. Run **PG-1** (Date Dimension) manually — run once
 2. Start **PG-2, PG-3, PG-4** — these are idempotent, safe to re-run
 3. Start **PG-5** — runs incrementally; first run loads all 531k room_bookings
 ### Verify load
 ```sql
 -- Oracle
 SELECT COUNT(*) FROM DIM_HOTEL;        -- should be 200 (+ more after SCD2 changes)
 SELECT COUNT(*) FROM DIM_GUEST;        -- 100,000
 SELECT COUNT(*) FROM FACT_ROOM_BOOKING; -- 531,382
 SELECT last_key FROM ETL_WATERMARK WHERE entity_name = 'FACT_ROOM_BOOKING'; -- 531,382
 ```
 ### Verify SCD2 is working
 ```sql
 -- Should show 1 current version per hotel on initial load
 SELECT is_current, COUNT(*) FROM DIM_HOTEL GROUP BY is_current;
 -- Expected: IS_CURRENT=1, COUNT=200
 ```
 ---
 ## Stop / Restart
 **Stop MySQL (preserves data):**
 ```bash
 bash docker/stop.sh [--podman]
 ```
 **Restart MySQL:**
 ```bash
 bash docker/start.sh [--podman]
 ```
 **Full reset (delete all data):**
 ```bash
 bash docker/stop.sh --podman
 podman volume rm hotel-mysql-data
 bash docker/start.sh --podman
 dotnet run generator/generate.cs
 ```
--- a/docs/05-conclusion.md
+++ b/docs/05-conclusion.md
@@ -0,0 +1,83 @@
 # Conclusion
 ## What Was Built
 This project delivers a complete, working **Data Warehouse pipeline** for the Hotel Reservations domain:
 | Layer | What was built | Scale |
 |-------|---------------|-------|
 | OLTP | MySQL 8.4, 13-table normalized schema | ~635,000 rows |
 | Data generation | .NET 10 C# script, realistic seasonal distribution | 500K bookings in ~3 min |
 | ETL | Apache NiFi, 5 process groups | full + incremental loads |
 | Data Mart | Oracle star schema, SCD Type 2 on DIM_HOTEL | 1 fact + 6 dims |
 ---
 ## Design Decisions
 ### Synthetic data generation instead of a Kaggle dataset
 The decision to generate data rather than use a pre-existing dataset was deliberate. Publicly available hotel datasets are either too small (thousands of rows) or lack the normalized relational structure needed to demonstrate a realistic OLTP-to-DW pipeline. The generator produces statistically realistic data:
 - Seasonal booking distribution (summer peak, winter trough)
 - Realistic stay-length distribution (30% one-night stays)
 - Varied status distribution (80% completed, 10% confirmed, 7% cancelled, 3% no-show)
 - Revenue rates tied to actual seasonal pricing periods
 ### SCD Type 2 on DIM_HOTEL only
 SCD Type 2 adds operational complexity — it requires staging tables, a two-phase SQL update, and SCD2-aware fact inserts. Applying it to every dimension would make the ETL unnecessarily complex for the analytical benefit gained.
 DIM_HOTEL is the right candidate because:
 - Star rating changes (3★→4★ after renovation) directly affect revenue benchmarks
 - Chain affiliation changes (hotel joins or leaves a franchise) affect chain-level reporting
 - Tracking these historically is the core value proposition of dimensional modelling
 Guests, countries, room types, and hotel chains all change rarely or in ways that don't affect historical analysis — SCD Type 1 (overwrite) is appropriate.
 ### Watermark-based incremental fact loading
 The fact table uses `source_rb_id` (the MySQL `room_booking_id`) as a natural key and applies a `NOT EXISTS` guard on every insert. Combined with the `ETL_WATERMARK` table, this makes PG-5 both **incremental** (only processes new rows) and **idempotent** (safe to re-run without creating duplicates). This pattern is production-standard and would scale cleanly to a real operational system.
 ### Integer date keys in DIM_DATE
 `date_key` is stored as `NUMBER(8)` in YYYYMMDD format rather than a FK to a DATE column. This allows:
 - Fast range predicates: `WHERE checkin_date_key BETWEEN 20240601 AND 20240831`
 - No JOIN to get the date value when it's used directly in GROUP BY
 - Human-readable values in query results without formatting
 ---
 ## Analytical Capabilities
 The data mart enables the following categories of OLAP queries:
 **Revenue analysis:**
 - Total revenue by country, city, hotel chain, star category
 - Revenue trend over time (monthly, quarterly, yearly)
 - Revenue split by booking status and room type
 **Occupancy analysis:**
 - Room-nights sold per hotel, per season
 - Average stay duration by guest country
 - Cancellation rates by period and hotel category
 **SCD2-specific analysis:**
 - Compare revenue performance of hotels before and after star rating upgrade
 - Identify which hotel version (chain affiliation) was more profitable
 **Guest origin analysis:**
 - Which countries generate the most bookings and revenue
 - Cross-country booking patterns (guest country vs hotel country)
 ---
 ## Limitations and Possible Extensions
 | Limitation | Possible extension |
 |------------|-------------------|
 | Static OLTP data (no live updates) | Add a NiFi timer to simulate ongoing bookings |
 | No SCD2 on DIM_ROOM | Add room type tracking for renovation analysis |
 | Single fact table | Add a second fact table for daily hotel occupancy (snapshot fact) |
 | No data quality checks in NiFi | Add RouteOnAttribute + dead-letter queue for failed records |
 | Oracle target is university lab | Package with Oracle XE Docker container for self-contained demo |
--- a/docs/nifi-flow.md
+++ b/docs/nifi-flow.md
@@ -0,0 +1,451 @@
 # NiFi ETL Flow — Hotel Reservations Data Mart
 ## Overview
 The flow moves data from **MySQL 8.4 OLTP** (source) into **Oracle Data Mart** (target).  
 It is organized into **5 Process Groups** that run in sequence, controlled by a top-level scheduler.
 ```
 [PG-1: Date Dim] → [PG-2: Static Dims] → [PG-3: SCD2 Hotel Dim] → [PG-4: SCD1 Guest] → [PG-5: Fact (incremental)]
 ```
 Each PG has a single **Input Port** and **Output Port** so the orchestrator can chain them with connections.
 ---
 ## Controller Services (shared by all PGs)
 | Name | Type | Config |
 |------|------|--------|
 | `MySQL_DBCPService` | DBCPConnectionPool | Driver: `com.mysql.cj.jdbc.Driver`; URL: `jdbc:mysql://127.0.0.1:13306/hotel_reservations`; User: `root`; Pwd: `hotel2025root` |
 | `Oracle_DBCPService` | DBCPConnectionPool | Driver: `oracle.jdbc.OracleDriver`; URL: `jdbc:oracle:thin:@<host>:1521:<sid>`; User: `<schema>`; Pwd: `<pwd>` |
 | `JsonReader` | JsonTreeReader | default settings |
 | `JsonWriter` | JsonRecordSetWriter | default settings |
 | `AvroReader` | AvroReader | default settings |
 ---
 ## PG-1: Load Date Dimension
 **Runs once** (or when extending the date range). Populates `DIM_DATE` for 2020–2030.
 ```
 GenerateFlowFile → ExecuteScript → SplitJson → EvaluateJsonPath → PutSQL
 ```
 ### Processors
 **GenerateFlowFile**
 - Run Schedule: manual (run once via right-click → Run Once)
 - Custom Text: `{}`
 **ExecuteScript** (Groovy)
 ```groovy
 import groovy.json.JsonOutput
 import java.time.*
 def rows = []
 def d = LocalDate.of(2020, 1, 1)
 def end = LocalDate.of(2030, 12, 31)
 while (!d.isAfter(end)) {
    def m = d.monthValue
    def season = (m >= 6 && m <= 8) ? 'Peak'
               : (m >= 3 && m <= 5) ? 'High'
               : (m >= 9 && m <= 11) ? 'Autumn'
               : 'Winter'
    rows << [
        date_key:        d.format(java.time.format.DateTimeFormatter.ofPattern('yyyyMMdd')) as int,
        full_date:       d.toString(),
        year:            d.year,
        quarter:         ((m - 1) / 3 + 1) as int,
        month:           m,
        month_name:      d.month.toString().capitalize(),
        week_number:     d.get(java.time.temporal.WeekFields.ISO.weekOfYear()),
        day_of_month:    d.dayOfMonth,
        day_name:        d.dayOfWeek.toString().capitalize(),
        is_weekend:      (d.dayOfWeek.value >= 6) ? 1 : 0,
        is_business_day: (d.dayOfWeek.value <= 5) ? 1 : 0,
        season:          season
    ]
    d = d.plusDays(1)
 }
 def ff = session.create()
 ff = session.write(ff, { out -> out.write(JsonOutput.toJson(rows).bytes) } as OutputStreamCallback)
 ff = session.putAttribute(ff, 'mime.type', 'application/json')
 session.transfer(ff, REL_SUCCESS)
 ```
 **SplitJson**
 - JsonPath Expression: `$.*`
 **EvaluateJsonPath**
 - Destination: `flowfile-attribute`
 - Attributes: `date_key`, `full_date`, `year`, `quarter`, `month`, `month_name`, `week_number`, `day_of_month`, `day_name`, `is_weekend`, `is_business_day`, `season`
 **PutSQL**
 - JDBC Connection Pool: `Oracle_DBCPService`
 - SQL Statement:
 ```sql
 INSERT INTO DIM_DATE (date_key, full_date, year, quarter, month, month_name,
    week_number, day_of_month, day_name, is_weekend, is_business_day, season)
 VALUES (${date_key}, TO_DATE('${full_date}','YYYY-MM-DD'), ${year}, ${quarter},
    ${month}, '${month_name}', ${week_number}, ${day_of_month},
    '${day_name}', ${is_weekend}, ${is_business_day}, '${season}')
 ```
 ---
 ## PG-2: Static Dimensions (SCD Type 1)
 Loads `DIM_COUNTRY`, `DIM_STAR_RATING`, `DIM_HOTEL_CHAIN` from MySQL.  
 Uses **MERGE INTO** so the flow is idempotent — re-running it updates changed rows and inserts new ones.
 Each sub-flow follows the same pattern:
 ```
 ExecuteSQL(MySQL) → ConvertAvroToJSON → SplitJson → EvaluateJsonPath → PutSQL(MERGE)
 ```
 ### 2a — DIM_COUNTRY
 **ExecuteSQL** — Connection Pool: `MySQL_DBCPService`
 ```sql
 SELECT country_id, code, name, currency FROM country ORDER BY country_id
 ```
 **EvaluateJsonPath** attributes: `country_id`, `code`, `name`, `currency`
 **PutSQL**
 ```sql
 MERGE INTO DIM_COUNTRY tgt
 USING (SELECT 1 FROM DUAL) src ON (tgt.country_id = ${country_id})
 WHEN MATCHED THEN
    UPDATE SET tgt.code = '${code}', tgt.name = '${name}', tgt.currency = '${currency}'
 WHEN NOT MATCHED THEN
    INSERT (country_id, code, name, currency)
    VALUES (${country_id}, '${code}', '${name}', '${currency}')
 ```
 ### 2b — DIM_STAR_RATING
 **ExecuteSQL**
 ```sql
 SELECT star_rating_id, code, description FROM star_rating ORDER BY code
 ```
 **PutSQL**
 ```sql
 MERGE INTO DIM_STAR_RATING tgt
 USING (SELECT 1 FROM DUAL) src ON (tgt.star_rating_id = ${star_rating_id})
 WHEN MATCHED THEN
    UPDATE SET tgt.code = ${code}, tgt.description = '${description}'
 WHEN NOT MATCHED THEN
    INSERT (star_rating_id, code, description)
    VALUES (${star_rating_id}, ${code}, '${description}')
 ```
 ### 2c — DIM_HOTEL_CHAIN
 **ExecuteSQL**
 ```sql
 SELECT hotel_chain_id, code, name FROM hotel_chain ORDER BY hotel_chain_id
 ```
 **PutSQL**
 ```sql
 MERGE INTO DIM_HOTEL_CHAIN tgt
 USING (SELECT 1 FROM DUAL) src ON (tgt.hotel_chain_id = ${hotel_chain_id})
 WHEN MATCHED THEN
    UPDATE SET tgt.code = '${code}', tgt.name = '${name}'
 WHEN NOT MATCHED THEN
    INSERT (hotel_chain_id, code, name)
    VALUES (${hotel_chain_id}, '${code}', '${name}')
 ```
 ---
 ## PG-3: DIM_HOTEL — SCD Type 2
 This is the analytically significant dimension. Hotels change star rating and chain affiliation over time (renovations, rebrandings). SCD Type 2 preserves history so reports can accurately show revenue by star category **at the time of booking**, not just today's category.
 **Architecture:** NiFi stages raw data into `STG_HOTEL`, then an `ExecuteScript` runs the SCD2 SQL logic in a single Oracle transaction.
 ```
 [Truncate STG] → [Load STG from MySQL] → [Apply SCD2 SQL]
 ```
 ### Step A: Truncate staging
 **GenerateFlowFile** → **PutSQL**
 ```sql
 TRUNCATE TABLE STG_HOTEL
 ```
 ### Step B: Load staging from MySQL
 **ExecuteSQL** — `MySQL_DBCPService`
 ```sql
 SELECT
    h.hotel_id,
    hc.code   AS chain_code,
    c.code    AS country_code,
    sr.code   AS star_code,
    h.code,
    h.name,
    h.city
 FROM hotel h
 JOIN country c      ON c.country_id    = h.country_id
 JOIN star_rating sr ON sr.star_rating_id = h.star_rating_id
 LEFT JOIN hotel_chain hc ON hc.hotel_chain_id = h.hotel_chain_id
 ORDER BY h.hotel_id
 ```
 **ConvertAvroToJSON** → **SplitJson** (`$.*`)
 **EvaluateJsonPath** attributes: `hotel_id`, `chain_code`, `country_code`, `star_code`, `code`, `name`, `city`
 **PutSQL** → `STG_HOTEL`
 ```sql
 INSERT INTO STG_HOTEL (hotel_id, chain_code, country_code, star_code, code, name, city)
 VALUES (${hotel_id}, NULLIF('${chain_code}',''), '${country_code}', ${star_code}, '${code}', '${name}', '${city}')
 ```
 ### Step C: Apply SCD2 logic
 **GenerateFlowFile** (runs after B finishes) → **ExecuteScript** (Groovy)
 The Groovy script opens a JDBC connection and executes two SQL statements in one transaction:
 ```groovy
 import java.sql.*
 def conn = context.controllerServiceLookup
    .getControllerService('Oracle_DBCPService_ID')
    .getConnection()
 conn.autoCommit = false
 try {
    // 1. Expire records whose tracked attributes changed
    conn.prepareStatement("""
        UPDATE DIM_HOTEL dh
        SET    dh.expiry_date = TRUNC(SYSDATE) - 1,
               dh.is_current  = 0
        WHERE  dh.is_current = 1
        AND EXISTS (
            SELECT 1 FROM STG_HOTEL s
            WHERE  s.hotel_id = dh.source_hotel_id
            AND (
                NVL(s.chain_code,'~') != NVL((
                    SELECT hc.code FROM DIM_HOTEL_CHAIN hc
                    WHERE hc.hotel_chain_key = dh.hotel_chain_key),'~')
                OR s.star_code != (
                    SELECT ds.code FROM DIM_STAR_RATING ds
                    WHERE ds.star_rating_key = dh.star_rating_key)
                OR s.city != dh.city
            )
        )
    """).executeUpdate()
    // 2. Insert new version for changed hotels + insert brand-new hotels
    conn.prepareStatement("""
        INSERT INTO DIM_HOTEL (
            source_hotel_id, hotel_chain_key, country_key, star_rating_key,
            code, name, city, effective_date, expiry_date, is_current)
        SELECT
            s.hotel_id,
            (SELECT hc.hotel_chain_key FROM DIM_HOTEL_CHAIN hc WHERE hc.code = s.chain_code),
            (SELECT dc.country_key     FROM DIM_COUNTRY     dc WHERE dc.code = s.country_code),
            (SELECT ds.star_rating_key FROM DIM_STAR_RATING ds WHERE ds.code = s.star_code),
            s.code, s.name, s.city,
            TRUNC(SYSDATE), NULL, 1
        FROM STG_HOTEL s
        WHERE NOT EXISTS (
            SELECT 1 FROM DIM_HOTEL d
            WHERE  d.source_hotel_id = s.hotel_id
            AND    d.is_current = 1
        )
    """).executeUpdate()
    conn.commit()
 } catch (Exception e) {
    conn.rollback()
    throw e
 } finally {
    conn.close()
 }
 def ff = session.create()
 session.transfer(ff, REL_SUCCESS)
 ```
 ---
 ## PG-4: DIM_GUEST — SCD Type 1
 Guest personal data (city, country) can change without any analytical value in tracking the history. Plain MERGE/upsert is correct here.
 ```
 ExecuteSQL(MySQL) → ConvertAvroToJSON → SplitJson → EvaluateJsonPath → PutSQL(MERGE)
 ```
 **ExecuteSQL** — `MySQL_DBCPService`
 ```sql
 SELECT g.guest_id, c.code AS country_code, g.name, g.city
 FROM guest g
 LEFT JOIN country c ON c.country_id = g.country_id
 ORDER BY g.guest_id
 ```
 **EvaluateJsonPath** attributes: `guest_id`, `country_code`, `name`, `city`
 **PutSQL**
 ```sql
 MERGE INTO DIM_GUEST tgt
 USING (SELECT 1 FROM DUAL) src ON (tgt.guest_id = ${guest_id})
 WHEN MATCHED THEN
    UPDATE SET
        tgt.country_key = (SELECT country_key FROM DIM_COUNTRY WHERE code = NULLIF('${country_code}','')),
        tgt.name        = '${name}',
        tgt.city        = NULLIF('${city}','')
 WHEN NOT MATCHED THEN
    INSERT (guest_id, country_key, name, city)
    VALUES (
        ${guest_id},
        (SELECT country_key FROM DIM_COUNTRY WHERE code = NULLIF('${country_code}','')),
        '${name}',
        NULLIF('${city}','')
    )
 ```
 > **Note:** DIM_ROOM is also SCD Type 1 — load it the same way as DIM_GUEST, joining `hotel_room` with `room_type` in MySQL and MERGEing into `DIM_ROOM` (surrogate key lookup via `source_hotel_id + IS_CURRENT=1` from DIM_HOTEL).
 ---
 ## PG-5: FACT_ROOM_BOOKING — Incremental Load (Watermark)
 The fact table is loaded **incrementally**: only `room_booking` rows with `room_booking_id` greater than the last loaded value are processed. The watermark is stored in `ETL_WATERMARK` in Oracle.
 `source_rb_id` on `FACT_ROOM_BOOKING` has a UNIQUE constraint, so re-running is safe — duplicates are silently skipped.
 ```
 [Read Watermark] → [ExecuteSQL MySQL] → [ConvertAvroToJSON] → [SplitJson]
    → [EvaluateJsonPath] → [PutSQL FACT] → [Update Watermark]
 ```
 ### Step A: Read watermark
 **ExecuteSQL** — `Oracle_DBCPService`
 ```sql
 SELECT last_key FROM ETL_WATERMARK WHERE entity_name = 'FACT_ROOM_BOOKING'
 ```
 **ConvertAvroToJSON** → **EvaluateJsonPath**
 - `watermark` ← `$.last_key`
 ### Step B: Load from MySQL
 **ExecuteSQL** — `MySQL_DBCPService`  
 SQL Statement (use attribute `${watermark}`):
 ```sql
 SELECT
    rb.room_booking_id,
    rb.room_id,
    rb.date_from,
    rb.date_to,
    rb.nightly_rate,
    rb.total_amount,
    b.guest_id,
    b.status AS booking_status,
    DATEDIFF(rb.date_to, rb.date_from) AS nights_stayed
 FROM room_booking rb
 JOIN booking b ON b.booking_id = rb.booking_id
 WHERE rb.room_booking_id > ${watermark}
 ORDER BY rb.room_booking_id
 LIMIT 50000
 ```
 > Set LIMIT to control batch size. Run PG-5 in a loop (using a Timer-driven GenerateFlowFile) until no rows come back.
 ### Step C: Split + extract attributes
 **ConvertAvroToJSON** → **SplitJson** (`$.*`)
 **EvaluateJsonPath** attributes:
 `room_booking_id`, `room_id`, `guest_id`, `date_from`, `date_to`, `nightly_rate`, `total_amount`, `booking_status`, `nights_stayed`
 ### Step D: Insert into fact table
 **PutSQL** — `Oracle_DBCPService`
 ```sql
 INSERT INTO FACT_ROOM_BOOKING (
    source_rb_id, hotel_key, hotel_chain_key, room_key, guest_key, country_key,
    star_rating_key, checkin_date_key, checkout_date_key,
    booking_status, nights_stayed, nightly_rate, total_amount)
 SELECT
    ${room_booking_id},
    dh.hotel_key,
    dh.hotel_chain_key,
    dr.room_key,
    dg.guest_key,
    dg.country_key,
    dh.star_rating_key,
    TO_NUMBER(TO_CHAR(TO_DATE('${date_from}','YYYY-MM-DD'), 'YYYYMMDD')),
    TO_NUMBER(TO_CHAR(TO_DATE('${date_to}',  'YYYY-MM-DD'), 'YYYYMMDD')),
    '${booking_status}',
    ${nights_stayed},
    TO_NUMBER('${nightly_rate}', '9999990D99', 'NLS_NUMERIC_CHARACTERS=''.,'''),
    TO_NUMBER('${total_amount}', '9999990D99', 'NLS_NUMERIC_CHARACTERS=''.,''')
 FROM
    DIM_ROOM   dr,
    DIM_GUEST  dg,
    DIM_HOTEL  dh
 WHERE
    dr.room_id          = ${room_id}
    AND dg.guest_id     = ${guest_id}
    AND dh.hotel_key    = dr.hotel_key
    -- SCD2 lookup: find hotel version active at check-in date
    AND dh.effective_date <= TO_DATE('${date_from}','YYYY-MM-DD')
    AND (dh.expiry_date IS NULL OR dh.expiry_date > TO_DATE('${date_from}','YYYY-MM-DD'))
    -- Idempotent: skip if already loaded
    AND NOT EXISTS (
        SELECT 1 FROM FACT_ROOM_BOOKING f WHERE f.source_rb_id = ${room_booking_id}
    )
 ```
 > The `DH.EFFECTIVE_DATE / EXPIRY_DATE` condition is the payoff of SCD Type 2: the fact row always references the hotel dimension version that was true **when the guest actually checked in**, not what the hotel looks like today.
 **Ignore Errors** on PutSQL (route `failure` → funnel) — UNIQUE constraint violations on `source_rb_id` are expected and harmless on re-runs.
 ### Step E: Update watermark
 After the PutSQL succeeds, update the watermark with the highest `room_booking_id` seen in this batch.
 **UpdateAttribute**
 - `max_rb_id` ← `${room_booking_id}` (NiFi Expression Language `max()` across the batch via a custom processor or MergeContent trick)
 > Simplest approach: add a final **ExecuteSQL** that runs after the batch:
 ```sql
 UPDATE ETL_WATERMARK
 SET last_key   = (SELECT MAX(source_rb_id) FROM FACT_ROOM_BOOKING),
    last_run_ts = SYSTIMESTAMP
 WHERE entity_name = 'FACT_ROOM_BOOKING'
 ```
 ---
 ## Execution Order & Scheduling
 | PG | Trigger | Frequency |
 |----|---------|-----------|
 | PG-1 (Date Dim) | Manual (run once) | — |
 | PG-2 (Static Dims) | Timer — 24h | Daily |
 | PG-3 (DIM_HOTEL SCD2) | Timer — 24h | Daily, after PG-2 |
 | PG-4 (DIM_GUEST SCD1) | Timer — 24h | Daily, after PG-3 |
 | PG-5 (Fact incremental) | Timer — 1h | Hourly |
 Chain PG-2 → PG-3 → PG-4 by connecting each PG's Output Port to the next PG's Input Port via a **success** relationship.
 ---
 ## Why SCD Type 2 for DIM_HOTEL?
 A hotel being upgraded from 3★ to 4★ changes its rate tier going forward. If we just overwrite the dimension (SCD1), all historical bookings would suddenly appear to have been made in a 4★ hotel — inflating average revenue per star category in reports. SCD2 preserves the correct picture: every fact row points to the exact hotel version that was true at check-in.
--- a/generator/generate.cs
+++ b/generator/generate.cs
@@ -0,0 +1,540 @@
 #:package MySqlConnector@2.3.7
 using System.Text;
 using System.Globalization;
 using MySqlConnector;
 // ── Config ────────────────────────────────────────────────────────────────────
 const string DSN         = "Server=127.0.0.1;Port=13306;Database=hotel_reservations;Uid=root;Pwd=hotel2025root;AllowLoadLocalInfile=true;";
 const int    HOTEL_COUNT = 200;
 const int    GUEST_COUNT = 100_000;
 const int    BOOKING_COUNT = 500_000;
 const int    BATCH        = 500;
 const int    SEED         = 42;
 var rng = new Random(SEED);
 // ── DB helpers ────────────────────────────────────────────────────────────────
 await using var conn = new MySqlConnection(DSN);
 await conn.OpenAsync();
 Console.WriteLine("Connected.");
 await new MySqlCommand("SET foreign_key_checks=0, unique_checks=0", conn).ExecuteNonQueryAsync();
 async Task Exec(string sql)
 {
    await using var cmd = new MySqlCommand(sql, conn);
    cmd.CommandTimeout = 300;
    await cmd.ExecuteNonQueryAsync();
 }
 async Task<long> ExecScalar(string sql)
 {
    await using var cmd = new MySqlCommand(sql, conn);
    return Convert.ToInt64(await cmd.ExecuteScalarAsync());
 }
 // Bulk insert: builds a single INSERT ... VALUES (...),(...),...
 async Task BulkInsert(string table, string columns, List<string> valueTuples)
 {
    for (int i = 0; i < valueTuples.Count; i += BATCH)
    {
        var batch = valueTuples.Skip(i).Take(BATCH);
        await Exec($"INSERT INTO {table} ({columns}) VALUES {string.Join(',', batch)}");
    }
 }
 string S(string? s) => s == null ? "NULL" : $"'{s.Replace("'", "''")}'";
 string N(object? n) => n == null ? "NULL" : (n is IFormattable f) ? f.ToString(null, CultureInfo.InvariantCulture) : n.ToString()!;
 string D(DateTime d) => $"'{d:yyyy-MM-dd}'";
 string DT(DateTime d) => $"'{d:yyyy-MM-dd HH:mm:ss}'";
 // ── Reference data ────────────────────────────────────────────────────────────
 // ── 1. hotel_chain ────────────────────────────────────────────────────────────
 Console.WriteLine("[1/8] hotel_chain");
 var chains = new (string Code, string Name)[]
 {
    ("HLT",  "Hilton Worldwide"),
    ("MRT",  "Marriott International"),
    ("HYT",  "Hyatt Hotels Corporation"),
    ("IHG",  "InterContinental Hotels Group"),
    ("WYN",  "Wyndham Hotels & Resorts"),
    ("ACC",  "Accor"),
    ("BW",   "Best Western Hotels"),
    ("RAD",  "Radisson Hotels"),
    ("MEL",  "Meliá Hotels International"),
    ("NH",   "NH Hotel Group"),
 };
 await BulkInsert("hotel_chain", "code, name",
    chains.Select(c => $"({S(c.Code)},{S(c.Name)})").ToList());
 var chainIds = new Dictionary<string, int>();
 {
    await using var cmd = new MySqlCommand("SELECT hotel_chain_id, code FROM hotel_chain", conn);
    await using var r = await cmd.ExecuteReaderAsync();
    while (await r.ReadAsync()) chainIds[r.GetString(1)] = r.GetInt32(0);
 }
 // ── 2. country ────────────────────────────────────────────────────────────────
 Console.WriteLine("[2/8] country");
 var countries = new (string Code, string Name, string Currency)[]
 {
    ("GB","United Kingdom","GBP"), ("FR","France","EUR"),       ("DE","Germany","EUR"),
    ("ES","Spain","EUR"),          ("IT","Italy","EUR"),         ("PT","Portugal","EUR"),
    ("NL","Netherlands","EUR"),    ("BE","Belgium","EUR"),       ("AT","Austria","EUR"),
    ("CH","Switzerland","CHF"),    ("SE","Sweden","SEK"),        ("NO","Norway","NOK"),
    ("DK","Denmark","DKK"),        ("PL","Poland","PLN"),        ("CZ","Czech Republic","CZK"),
    ("HU","Hungary","HUF"),        ("HR","Croatia","EUR"),       ("GR","Greece","EUR"),
    ("TR","Turkey","TRY"),         ("US","United States","USD"), ("CA","Canada","CAD"),
    ("MX","Mexico","MXN"),         ("BR","Brazil","BRL"),        ("AR","Argentina","ARS"),
    ("AU","Australia","AUD"),      ("NZ","New Zealand","NZD"),   ("JP","Japan","JPY"),
    ("CN","China","CNY"),          ("KR","South Korea","KRW"),   ("SG","Singapore","SGD"),
    ("TH","Thailand","THB"),       ("AE","United Arab Emirates","AED"),
    ("SA","Saudi Arabia","SAR"),   ("EG","Egypt","EGP"),         ("ZA","South Africa","ZAR"),
    ("IN","India","INR"),          ("MA","Morocco","MAD"),       ("TN","Tunisia","TND"),
    ("ID","Indonesia","IDR"),      ("MY","Malaysia","MYR"),
 };
 await BulkInsert("country", "code, name, currency",
    countries.Select(c => $"({S(c.Code)},{S(c.Name)},{S(c.Currency)})").ToList());
 var countryIds = new Dictionary<string, int>();
 {
    await using var cmd = new MySqlCommand("SELECT country_id, code FROM country", conn);
    await using var r = await cmd.ExecuteReaderAsync();
    while (await r.ReadAsync()) countryIds[r.GetString(1)] = r.GetInt32(0);
 }
 // ── 3. star_rating ────────────────────────────────────────────────────────────
 Console.WriteLine("[3/8] star_rating");
 await BulkInsert("star_rating", "code, description",
    Enumerable.Range(1, 5).Select(i => $"({i},{S(i + " Star")})").ToList());
 var starIds = new Dictionary<int, int>();
 {
    await using var cmd = new MySqlCommand("SELECT star_rating_id, code FROM star_rating", conn);
    await using var r = await cmd.ExecuteReaderAsync();
    while (await r.ReadAsync()) starIds[r.GetInt32(1)] = r.GetInt32(0);
 }
 // ── 4. hotel_characteristic ───────────────────────────────────────────────────
 Console.WriteLine("[4/8] hotel_characteristic");
 var characteristics = new (string Code, string Desc)[]
 {
    ("WIFI",        "Free WiFi"),          ("POOL",     "Swimming Pool"),
    ("GYM",         "Fitness Center"),     ("SPA",      "Spa & Wellness"),
    ("RESTAURANT",  "On-site Restaurant"), ("BAR",      "Hotel Bar"),
    ("PARKING",     "Free Parking"),       ("VALET",    "Valet Parking"),
    ("CONFERENCE",  "Conference Rooms"),   ("SHUTTLE",  "Airport Shuttle"),
    ("ROOM_SVC",    "Room Service"),       ("PETS",     "Pet Friendly"),
 };
 await BulkInsert("hotel_characteristic", "code, description",
    characteristics.Select(c => $"({S(c.Code)},{S(c.Desc)})").ToList());
 var charIds = new Dictionary<string, int>();
 {
    await using var cmd = new MySqlCommand("SELECT characteristic_id, code FROM hotel_characteristic", conn);
    await using var r = await cmd.ExecuteReaderAsync();
    while (await r.ReadAsync()) charIds[r.GetString(1)] = r.GetInt32(0);
 }
 // ── 5. room_type + rate_period + period_room_rate ─────────────────────────────
 Console.WriteLine("[5/8] room_type / rate_period / period_room_rate");
 var roomTypes = new (string Code, string Desc, decimal BaseRate, bool Smoking)[]
 {
    ("SINGLE",  "Single Room",        80m,  false),
    ("DOUBLE",  "Double Room",       120m,  false),
    ("TWIN",    "Twin Room",         115m,  false),
    ("DELUXE",  "Deluxe Double",     180m,  false),
    ("SUITE",   "Junior Suite",      280m,  false),
    ("EXEC",    "Executive Suite",   450m,  false),
    ("FAMILY",  "Family Room",       200m,  false),
 };
 await BulkInsert("room_type", "code, description, standard_rate, smoking_yn",
    roomTypes.Select(rt => $"({S(rt.Code)},{S(rt.Desc)},{N(rt.BaseRate)},0)").ToList());
 var roomTypeIds = new Dictionary<string, int>();
 {
    await using var cmd = new MySqlCommand("SELECT room_type_id, code FROM room_type", conn);
    await using var r = await cmd.ExecuteReaderAsync();
    while (await r.ReadAsync()) roomTypeIds[r.GetString(1)] = r.GetInt32(0);
 }
 // Seasons: month → multiplier
 var ratePeriods = new (string Code, string Desc, int MonthFrom, int MonthTo, decimal Multiplier)[]
 {
    ("PEAK",    "Peak Season (Jun-Aug)",       6,  8,  1.5m),
    ("HIGH",    "High Season (Mar-May)",        3,  5,  1.2m),
    ("AUTUMN",  "Autumn Season (Sep-Nov)",      9,  11, 1.1m),
    ("WINTER",  "Winter Season (Dec-Feb)",      12, 2,  0.9m),
 };
 await BulkInsert("rate_period", "code, description, month_from, month_to",
    ratePeriods.Select(rp => $"({S(rp.Code)},{S(rp.Desc)},{rp.MonthFrom},{rp.MonthTo})").ToList());
 var ratePeriodIds = new Dictionary<string, int>();
 {
    await using var cmd = new MySqlCommand("SELECT rate_period_id, code FROM rate_period", conn);
    await using var r = await cmd.ExecuteReaderAsync();
    while (await r.ReadAsync()) ratePeriodIds[r.GetString(1)] = r.GetInt32(0);
 }
 // period_room_rate: rate = base_rate * season_multiplier
 var prrRows = new List<string>();
 foreach (var rt in roomTypes)
    foreach (var rp in ratePeriods)
    {
        var rate = Math.Round(rt.BaseRate * rp.Multiplier, 2);
        prrRows.Add($"({roomTypeIds[rt.Code]},{ratePeriodIds[rp.Code]},{N(rate)})");
    }
 await BulkInsert("period_room_rate", "room_type_id, rate_period_id, rate", prrRows);
 // Build month → rate lookup in memory
 var monthToRatePeriodId = new Dictionary<int, int>();
 foreach (var rp in ratePeriods)
 {
    if (rp.MonthFrom <= rp.MonthTo)
        for (int m = rp.MonthFrom; m <= rp.MonthTo; m++)
            monthToRatePeriodId[m] = ratePeriodIds[rp.Code];
    else // wraps year (Dec-Feb)
    {
        for (int m = rp.MonthFrom; m <= 12; m++) monthToRatePeriodId[m] = ratePeriodIds[rp.Code];
        for (int m = 1; m <= rp.MonthTo; m++)    monthToRatePeriodId[m] = ratePeriodIds[rp.Code];
    }
 }
 // Build (room_type_id, rate_period_id) → rate lookup
 var rateMap = new Dictionary<(int, int), decimal>();
 foreach (var rt in roomTypes)
    foreach (var rp in ratePeriods)
        rateMap[(roomTypeIds[rt.Code], ratePeriodIds[rp.Code])] =
            Math.Round(rt.BaseRate * rp.Multiplier, 2);
 // ── 6. hotel + hotel_room + hotel_hotel_characteristic ────────────────────────
 Console.WriteLine("[6/8] hotel / hotel_room / hotel_hotel_characteristic");
 var hotelCities = new (string City, string Country)[]
 {
    ("London","GB"),      ("Manchester","GB"),   ("Edinburgh","GB"),
    ("Paris","FR"),       ("Lyon","FR"),         ("Nice","FR"),
    ("Berlin","DE"),      ("Munich","DE"),        ("Hamburg","DE"),
    ("Madrid","ES"),      ("Barcelona","ES"),     ("Seville","ES"),
    ("Rome","IT"),        ("Milan","IT"),         ("Florence","IT"),
    ("Lisbon","PT"),      ("Porto","PT"),         ("Amsterdam","NL"),
    ("Vienna","AT"),      ("Zurich","CH"),        ("Geneva","CH"),
    ("Stockholm","SE"),   ("Oslo","NO"),          ("Copenhagen","DK"),
    ("Warsaw","PL"),      ("Prague","CZ"),        ("Budapest","HU"),
    ("Athens","GR"),      ("Istanbul","TR"),      ("New York","US"),
    ("Los Angeles","US"), ("Miami","US"),         ("Chicago","US"),
    ("Toronto","CA"),     ("Vancouver","CA"),     ("Sydney","AU"),
    ("Melbourne","AU"),   ("Tokyo","JP"),         ("Osaka","JP"),
    ("Singapore","SG"),   ("Bangkok","TH"),       ("Dubai","AE"),
    ("Mumbai","IN"),      ("Cape Town","ZA"),     ("Marrakech","MA"),
    ("Cairo","EG"),       ("Cancun","MX"),        ("Rio de Janeiro","BR"),
    ("Seoul","KR"),       ("Kuala Lumpur","MY"),
 };
 // Star rating distribution: 3★ most common, 5★ rarest
 int[] starWeights = [0, 5, 10, 40, 30, 15]; // index = star, value = weight
 int PickStar()
 {
    int roll = rng.Next(100);
    int cum = 0;
    for (int s = 1; s <= 5; s++) { cum += starWeights[s]; if (roll < cum) return s; }
    return 3;
 }
 var hotelRows    = new List<string>();
 var roomRows     = new List<string>();
 var hotelCharRows = new List<string>();
 var charCodes    = characteristics.Select(c => c.Code).ToArray();
 // Track room_type per hotel_room for later rate lookups (in-memory)
 // hotel_room gets an auto-increment ID; we'll load them after insert
 // So store: hotel index → list of (room_number, room_type_code)
 var hotelRoomTypes = new List<(int hotelIndex, string roomNumber, string roomTypeCode)>();
 string[] streetNames = ["Main St","Park Ave","King Rd","Grand Blvd","Lake Dr",
                        "Ocean Blvd","Hill Rd","Market St","Central Ave","Palace Rd"];
 for (int h = 0; h < HOTEL_COUNT; h++)
 {
    var (city, ctryCode) = hotelCities[h % hotelCities.Length];
    int chainIndex = rng.Next(chains.Length);
    // 20% of hotels are independent (no chain)
    int? chainId = rng.Next(100) < 20 ? null : chainIds[chains[chainIndex].Code];
    int star     = PickStar();
    int starId   = starIds[star];
    int ctryId   = countryIds[ctryCode];
    string code  = $"HTL{h+1:D4}";
    string name  = chainId == null
        ? $"The {city} Hotel"
        : $"{chains[chainIndex].Name.Split(' ')[0]} {city}";
    string addr  = $"{rng.Next(1, 200)} {streetNames[rng.Next(streetNames.Length)]}";
    string url   = $"https://www.{code.ToLower()}.example.com";
    hotelRows.Add($"({N(chainId)},{ctryId},{starId},{S(code)},{S(name)},{S(addr)},{S("00000")},{S(city)},{S(url)})");
    // Characteristics: 5★ gets all, lower stars get fewer
    int charCount = star switch { 5 => 11, 4 => 8, 3 => 6, 2 => 4, _ => 3 };
    var shuffled = charCodes.OrderBy(_ => rng.Next()).Take(charCount).ToArray();
    // Store char codes for later — we need hotel_id from DB first
    // Mark with h as placeholder; we'll match after insert
    foreach (var cc in shuffled)
        hotelCharRows.Add($"__HOTEL_{h}__,{charIds[cc]}");
    // Rooms: more rooms for higher star hotels
    int roomCount = star switch { 5 => rng.Next(40, 60), 4 => rng.Next(25, 40),
                                   3 => rng.Next(15, 25), 2 => rng.Next(8, 15), _ => rng.Next(5, 10) };
    // Room type distribution per star rating
    string[] typePool = star switch
    {
        5 => ["DOUBLE","DOUBLE","DELUXE","DELUXE","SUITE","SUITE","EXEC","FAMILY"],
        4 => ["SINGLE","DOUBLE","DOUBLE","DELUXE","SUITE","FAMILY"],
        3 => ["SINGLE","SINGLE","DOUBLE","DOUBLE","TWIN","FAMILY"],
        2 => ["SINGLE","SINGLE","DOUBLE","TWIN"],
        _ => ["SINGLE","SINGLE","DOUBLE"],
    };
    for (int r = 0; r < roomCount; r++)
    {
        int floor   = r / 10 + 1;
        string rnum = $"{floor}{(r % 10 + 1):D2}";
        string rtype = typePool[rng.Next(typePool.Length)];
        // Store for later (after we get real hotel IDs from DB)
        hotelRoomTypes.Add((h, rnum, rtype));
    }
 }
 await BulkInsert("hotel",
    "hotel_chain_id, country_id, star_rating_id, code, name, address, postcode, city, url",
    hotelRows);
 // Load hotel IDs in order
 var hotelIds = new List<int>();
 {
    await using var cmd = new MySqlCommand("SELECT hotel_id FROM hotel ORDER BY hotel_id", conn);
    await using var r = await cmd.ExecuteReaderAsync();
    while (await r.ReadAsync()) hotelIds.Add(r.GetInt32(0));
 }
 // Now build hotel_room rows with real hotel IDs
 foreach (var (hIdx, rnum, rtype) in hotelRoomTypes)
    roomRows.Add($"({hotelIds[hIdx]},{roomTypeIds[rtype]},{S(rnum)},{rnum[0] - '0'})");
 await BulkInsert("hotel_room", "hotel_id, room_type_id, room_number, floor", roomRows);
 // hotel_hotel_characteristic — replace placeholder with real hotel_id
 var hhcRows = hotelCharRows
    .Select(row => {
        var parts   = row.Split(',');
        var hIdx    = int.Parse(parts[0].Replace("__HOTEL_", "").Replace("__", ""));
        var charId  = parts[1];
        return $"({hotelIds[hIdx]},{charId})";
    })
    .Distinct()
    .ToList();
 await BulkInsert("hotel_hotel_characteristic", "hotel_id, characteristic_id", hhcRows);
 // Load rooms into memory: hotel_id → list of (room_id, room_type_id)
 var hotelRooms = new Dictionary<int, List<(int RoomId, int RoomTypeId)>>();
 {
    await using var cmd = new MySqlCommand("SELECT room_id, hotel_id, room_type_id FROM hotel_room", conn);
    await using var r = await cmd.ExecuteReaderAsync();
    while (await r.ReadAsync())
    {
        int rid = r.GetInt32(0), hid = r.GetInt32(1), rtid = r.GetInt32(2);
        if (!hotelRooms.ContainsKey(hid)) hotelRooms[hid] = [];
        hotelRooms[hid].Add((rid, rtid));
    }
 }
 // ── 7. guest ──────────────────────────────────────────────────────────────────
 Console.WriteLine("[7/8] guest");
 string[] firstNames =
 [
    "James","Mary","John","Patricia","Robert","Jennifer","Michael","Linda","William","Barbara",
    "David","Elizabeth","Richard","Susan","Joseph","Jessica","Thomas","Sarah","Charles","Karen",
    "Luca","Sofia","Marco","Giulia","Hans","Anna","Klaus","Maria","Pierre","Marie","Jean","Claire",
    "Miguel","Ana","Carlos","Carmen","Andrei","Ioana","Mihai","Elena","Tomasz","Agnieszka",
    "Dimitri","Eleni","Mehmet","Fatima","Yuki","Kenji","Haruto","Yuna","Wei","Fang","Li","Mei",
    "Ahmed","Layla","Omar","Nour","Raj","Priya","Arjun","Ananya","Lucas","Emma","Noah","Olivia",
    "Ethan","Ava","Mason","Isabella","Liam","Sophia","Oliver","Charlotte","Elijah","Amelia",
 ];
 string[] lastNames =
 [
    "Smith","Johnson","Williams","Brown","Jones","Garcia","Miller","Davis","Wilson","Moore",
    "Taylor","Anderson","Thomas","Jackson","White","Harris","Martin","Thompson","Young","Lee",
    "Rossi","Ferrari","Esposito","Romano","Müller","Schmidt","Fischer","Weber","Meyer","Wagner",
    "Dupont","Martin","Bernard","Petit","Dubois","Moreau","Laurent","Simon","Michel","Garcia",
    "Kowalski","Nowak","Wiśniewski","Wójcik","Kowalczyk","Kamiński","Lewandowski","Zieliński",
    "Papadopoulos","Georgiou","Yilmaz","Kaya","Tanaka","Sato","Suzuki","Watanabe","Ito","Yamamoto",
    "Wang","Li","Zhang","Liu","Chen","Yang","Huang","Zhao","Kim","Park","Lee","Choi","Patel",
    "Singh","Kumar","Sharma","Gupta","Ali","Hassan","Ahmed","Mohamed","Silva","Santos","Oliveira",
 ];
 string[] guestCities =
 [
    "London","Paris","Berlin","Madrid","Rome","Amsterdam","Vienna","Zurich","Brussels","Stockholm",
    "New York","Los Angeles","Chicago","Houston","Phoenix","Toronto","Vancouver","Sydney","Melbourne",
    "Tokyo","Seoul","Beijing","Shanghai","Singapore","Bangkok","Dubai","Mumbai","Cape Town",
    "Warsaw","Prague","Budapest","Athens","Istanbul","Lisbon","Oslo","Copenhagen","Helsinki",
 ];
 var countryList = countries.Select(c => c.Code).ToArray();
 var guestRows = new List<string>();
 for (int g = 0; g < GUEST_COUNT; g++)
 {
    string fn    = firstNames[rng.Next(firstNames.Length)];
    string ln    = lastNames[rng.Next(lastNames.Length)];
    string name  = $"{fn} {ln}";
    string email = $"{fn.ToLower()}.{ln.ToLower()}{rng.Next(100, 999)}@example.com";
    string city  = guestCities[rng.Next(guestCities.Length)];
    int    ctryId = countryIds[countryList[rng.Next(countryList.Length)]];
    guestRows.Add($"({ctryId},{S(name)},{S(email)},{S(city)})");
 }
 await BulkInsert("guest", "country_id, name, email, city", guestRows);
 var guestIdMin = (int)await ExecScalar("SELECT MIN(guest_id) FROM guest");
 var guestIdMax = (int)await ExecScalar("SELECT MAX(guest_id) FROM guest");
 // ── 8. booking + room_booking ─────────────────────────────────────────────────
 Console.WriteLine("[8/8] booking + room_booking");
 var dateStart = new DateTime(2022, 1, 1);
 var dateEnd   = new DateTime(2025, 12, 31);
 int dateRange = (dateEnd - dateStart).Days;
 // Seasonal weight: month → weight (higher = more bookings)
 int[] monthWeight = [0, 6, 5, 7, 9, 10, 14, 16, 15, 11, 9, 7, 11]; // Jan-Dec
 DateTime RandomCheckin()
 {
    // Rejection sampling to simulate seasonal distribution
    while (true)
    {
        var d = dateStart.AddDays(rng.Next(dateRange));
        if (rng.Next(16) < monthWeight[d.Month]) return d;
    }
 }
 int RandomNights() => rng.Next(100) switch
 {
    < 30 => 1,
    < 55 => 2,
    < 75 => 3,
    < 85 => 4,
    < 92 => 5,
    < 96 => rng.Next(6, 8),
    _    => rng.Next(8, 15),
 };
 string RandomStatus() => rng.Next(100) switch
 {
    < 80 => "completed",
    < 90 => "confirmed",
    < 97 => "cancelled",
    _    => "no_show",
 };
 // 90% single room, 8% two rooms, 2% three rooms
 int RandomRoomCount() => rng.Next(100) switch { < 90 => 1, < 98 => 2, _ => 3 };
 var bookingRows    = new List<string>();
 var roomBookingRows = new List<string>();
 // We need booking_id for room_booking FK.
 // Strategy: flush bookings in batches, then read back the auto-increment IDs,
 // then insert room_bookings for that batch.
 int bookingsDone = 0;
 while (bookingsDone < BOOKING_COUNT)
 {
    int batchSize = Math.Min(BATCH, BOOKING_COUNT - bookingsDone);
    bookingRows.Clear();
    roomBookingRows.Clear();
    for (int b = 0; b < batchSize; b++)
    {
        int      guestId  = guestIdMin + rng.Next(guestIdMax - guestIdMin + 1);
        int      hotelId  = hotelIds[rng.Next(hotelIds.Count)];
        DateTime checkin  = RandomCheckin();
        int      nights   = RandomNights();
        DateTime checkout = checkin.AddDays(nights);
        string   status   = RandomStatus();
        DateTime created  = checkin.AddDays(-rng.Next(1, 180));
        bookingRows.Add($"({guestId},{hotelId},{D(checkin)},{D(checkout)},{S(status)},{DT(created)})");
    }
    await Exec($"INSERT INTO booking (guest_id, hotel_id, date_from, date_to, status, created_at) VALUES {string.Join(',', bookingRows)}");
    long firstId = await ExecScalar("SELECT LAST_INSERT_ID()");
    // Re-derive checkin/nights from the same rng sequence is impossible after the fact,
    // so re-parse from inserted rows to build room_bookings
    // Simpler: re-read the batch back
    await using (var cmd = new MySqlCommand(
        $"SELECT booking_id, hotel_id, date_from, date_to, status FROM booking WHERE booking_id >= {firstId} ORDER BY booking_id", conn))
    await using (var reader = await cmd.ExecuteReaderAsync())
    {
        while (await reader.ReadAsync())
        {
            long    bookingId = reader.GetInt64(0);
            int     hid       = reader.GetInt32(1);
            DateTime dfrom    = reader.GetDateTime(2);
            DateTime dto      = reader.GetDateTime(3);
            string  status    = reader.GetString(4);
            int     nights    = (dto - dfrom).Days;
            if (!hotelRooms.ContainsKey(hid) || hotelRooms[hid].Count == 0) continue;
            // Skip room_bookings for cancelled/no_show sometimes
            if (status == "cancelled" && rng.Next(100) < 60) continue;
            if (status == "no_show"   && rng.Next(100) < 30) continue;
            int roomCount = RandomRoomCount();
            var available = hotelRooms[hid].OrderBy(_ => rng.Next()).Take(roomCount).ToList();
            foreach (var (roomId, roomTypeId) in available)
            {
                int ratePeriodId  = monthToRatePeriodId[dfrom.Month];
                decimal nightly   = rateMap[(roomTypeId, ratePeriodId)];
                decimal total     = Math.Round(nightly * nights, 2);
                roomBookingRows.Add($"({bookingId},{roomId},{D(dfrom)},{D(dto)},{N(nightly)},{N(total)})");
            }
        }
    }
    if (roomBookingRows.Count > 0)
        await Exec($"INSERT INTO room_booking (booking_id, room_id, date_from, date_to, nightly_rate, total_amount) VALUES {string.Join(',', roomBookingRows)}");
    bookingsDone += batchSize;
    if (bookingsDone % 10_000 == 0)
        Console.WriteLine($"  bookings: {bookingsDone:N0} / {BOOKING_COUNT:N0}");
 }
 Console.WriteLine();
 Console.WriteLine("── Row counts ───────────────────────────────");
 foreach (var t in new[]{"hotel_chain","country","star_rating","hotel_characteristic",
                         "room_type","rate_period","period_room_rate","hotel",
                         "hotel_room","hotel_hotel_characteristic","guest","booking","room_booking"})
 {
    long cnt = await ExecScalar($"SELECT COUNT(*) FROM {t}");
    Console.WriteLine($"  {t,-35} {cnt,10:N0}");
 }
 Console.WriteLine("Done.");
--- a/nesto.pdf
+++ b/nesto.pdf
--- a/sql/datamart_schema.sql
+++ b/sql/datamart_schema.sql
@@ -0,0 +1,187 @@
 create table ETL_WATERMARK
 (
    ENTITY_NAME VARCHAR2(50)           not null
        constraint PK_ETL_WATERMARK
            primary key,
    LAST_KEY    NUMBER(20)   default 0 not null,
    LAST_RUN_TS TIMESTAMP(6) default SYSTIMESTAMP
 )
 /
 create table STG_HOTEL
 (
    HOTEL_ID         NUMBER(10)    not null,
    HOTEL_CODE       VARCHAR2(20)  not null,
    HOTEL_NAME       VARCHAR2(150) not null,
    CITY             VARCHAR2(100) not null,
    COUNTRY_CODE     CHAR(2)       not null,
    COUNTRY_NAME     VARCHAR2(100) not null,
    CURRENCY         VARCHAR2(10)  not null,
    CHAIN_CODE       VARCHAR2(10),
    CHAIN_NAME       VARCHAR2(100),
    STAR_RATING      NUMBER(1)     not null,
    STAR_DESCRIPTION VARCHAR2(20)
 )
 /
 create table DIM_DATE
 (
    DATE_KEY        NUMBER(8)    not null
        constraint PK_DIM_DATE
            primary key,
    FULL_DATE       DATE         not null,
    YEAR            NUMBER(4)    not null,
    QUARTER         NUMBER(1)    not null,
    MONTH           NUMBER(2)    not null,
    MONTH_NAME      VARCHAR2(10) not null,
    WEEK_NUMBER     NUMBER(2)    not null,
    DAY_OF_MONTH    NUMBER(2)    not null,
    DAY_NAME        VARCHAR2(10) not null,
    IS_WEEKEND      NUMBER(1)    not null
        constraint CK_DIM_DATE_WEEKEND
            check (is_weekend IN (0, 1)),
    IS_BUSINESS_DAY NUMBER(1)    not null
        constraint CK_DIM_DATE_BUSINESS
            check (is_business_day IN (0, 1)),
    SEASON          VARCHAR2(10) not null
 )
 /
 create table DIM_HOTEL
 (
    HOTEL_KEY        NUMBER(10) default "IPZ19438"."ISEQ$$_303891".nextval generated as identity
 		constraint PK_DIM_HOTEL
 			primary key,
    SOURCE_HOTEL_ID  NUMBER(10)           not null,
    HOTEL_CODE       VARCHAR2(20)         not null,
    HOTEL_NAME       VARCHAR2(150)        not null,
    CITY             VARCHAR2(100)        not null,
    COUNTRY_CODE     CHAR(2)              not null,
    COUNTRY_NAME     VARCHAR2(100)        not null,
    CURRENCY         VARCHAR2(10)         not null,
    CHAIN_CODE       VARCHAR2(10),
    CHAIN_NAME       VARCHAR2(100),
    STAR_RATING      NUMBER(1)            not null,
    STAR_DESCRIPTION VARCHAR2(20),
    EFFECTIVE_DATE   DATE                 not null,
    EXPIRY_DATE      DATE,
    IS_CURRENT       NUMBER(1)  default 1 not null
        constraint CK_DIM_HOTEL_CURRENT
            check (is_current IN (0, 1))
 )
 /
 create table DIM_ROOM
 (
    ROOM_KEY              NUMBER(10) generated as identity
        constraint PK_DIM_ROOM
            primary key,
    SOURCE_ROOM_ID        NUMBER(10)    not null
        constraint UQ_DIM_ROOM
            unique,
    HOTEL_KEY             NUMBER(10)    not null
        constraint FK_DIM_ROOM_HOTEL
            references DIM_HOTEL,
    ROOM_NUMBER           VARCHAR2(10)  not null,
    FLOOR                 NUMBER(3)     not null,
    ROOM_TYPE_CODE        VARCHAR2(20)  not null,
    ROOM_TYPE_DESCRIPTION VARCHAR2(100) not null,
    SMOKING_YN            NUMBER(1)     not null
        constraint CK_DIM_ROOM_SMOKING
            check (smoking_yn IN (0, 1)),
    STANDARD_RATE         NUMBER(10, 2) not null
 )
 /
 create table DIM_GUEST
 (
    GUEST_KEY       NUMBER(10) generated as identity
        constraint PK_DIM_GUEST
            primary key,
    SOURCE_GUEST_ID NUMBER(10)    not null
        constraint UQ_DIM_GUEST
            unique,
    GUEST_NAME      VARCHAR2(150) not null,
    CITY            VARCHAR2(100),
    COUNTRY_CODE    CHAR(2),
    COUNTRY_NAME    VARCHAR2(100)
 )
 /
 create table FACT_ROOM_BOOKING
 (
    FACT_ID                  NUMBER(10) default "IPZ19438"."ISEQ$$_303902".nextval generated as identity
 		constraint PK_FACT_ROOM_BOOKING
 			primary key,
    SOURCE_RB_ID             NUMBER(10)           not null
        constraint UQ_FACT_ROOM_BOOKING_SRC
            unique,
    HOTEL_KEY                NUMBER(10)           not null
        constraint FK_FACT_HOTEL
            references DIM_HOTEL,
    ROOM_KEY                 NUMBER(10)           not null
        constraint FK_FACT_ROOM
            references DIM_ROOM,
    GUEST_KEY                NUMBER(10)           not null
        constraint FK_FACT_GUEST
            references DIM_GUEST,
    BOOKING_CREATED_DATE_KEY NUMBER(8)            not null
        constraint FK_FACT_BOOKING_DATE
            references DIM_DATE,
    CHECKIN_DATE_KEY         NUMBER(8)            not null
        constraint FK_FACT_CHECKIN_DATE
            references DIM_DATE,
    CHECKOUT_DATE_KEY        NUMBER(8)            not null
        constraint FK_FACT_CHECKOUT_DATE
            references DIM_DATE,
    BOOKING_STATUS           VARCHAR2(20)         not null,
    BOOKING_COUNT            NUMBER(1)  default 1 not null
        constraint CK_FACT_BOOKING_COUNT
            check (booking_count = 1),
    NIGHTS_STAYED            NUMBER(4)            not null,
    NIGHTLY_RATE             NUMBER(10, 2)        not null,
    TOTAL_AMOUNT             NUMBER(12, 2)        not null
 )
 /
 create table STG_GUEST
 (
    SOURCE_GUEST_ID NUMBER(10)    not null,
    GUEST_NAME      VARCHAR2(150) not null,
    CITY            VARCHAR2(100),
    COUNTRY_CODE    CHAR(2),
    COUNTRY_NAME    VARCHAR2(100)
 )
 /
 create table STG_ROOM
 (
    SOURCE_ROOM_ID        NUMBER(10)    not null,
    HOTEL_CODE            VARCHAR2(20)  not null,
    ROOM_NUMBER           VARCHAR2(10)  not null,
    FLOOR                 NUMBER(3)     not null,
    ROOM_TYPE_CODE        VARCHAR2(20)  not null,
    ROOM_TYPE_DESCRIPTION VARCHAR2(100) not null,
    SMOKING_YN            NUMBER(1)     not null,
    STANDARD_RATE         NUMBER(10, 2) not null,
    HOTEL_ID              NUMBER(10)
 )
 /
 create table STG_ROOM_BOOKING
 (
    SOURCE_RB_ID         NUMBER(10)          not null,
    GUEST_ID             NUMBER(10)          not null,
    BOOKING_CREATED_DATE DATE                not null,
    CHECKIN_DATE         DATE                not null,
    CHECKOUT_DATE        DATE                not null,
    BOOKING_STATUS       VARCHAR2(20)        not null,
    BOOKING_COUNT        NUMBER(1) default 1 not null,
    NIGHTS_STAYED        NUMBER(4)           not null,
    NIGHTLY_RATE         NUMBER(10, 2)       not null,
    TOTAL_AMOUNT         NUMBER(12, 2)       not null,
    HOTEL_ID             NUMBER(10)          not null,
    ROOM_ID              NUMBER(10)          not null
 )
 /
--- a/sql/schema.sql
+++ b/sql/schema.sql
@@ -0,0 +1,154 @@
 CREATE DATABASE IF NOT EXISTS hotel_reservations
    CHARACTER SET utf8mb4
    COLLATE utf8mb4_unicode_ci;
 USE hotel_reservations;
 -- ─────────────────────────────────────────────────────────────────────────────
 -- LOOKUP / REFERENCE TABLES
 -- ─────────────────────────────────────────────────────────────────────────────
 CREATE TABLE hotel_chain (
    hotel_chain_id  INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    code            VARCHAR(10)     NOT NULL,
    name            VARCHAR(100)    NOT NULL,
    PRIMARY KEY (hotel_chain_id),
    UNIQUE KEY uq_chain_code (code)
 );
 CREATE TABLE country (
    country_id  INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    code        CHAR(2)         NOT NULL,
    name        VARCHAR(100)    NOT NULL,
    currency    VARCHAR(10)     NOT NULL,
    PRIMARY KEY (country_id),
    UNIQUE KEY uq_country_code (code)
 );
 CREATE TABLE star_rating (
    star_rating_id  INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    code            TINYINT UNSIGNED NOT NULL,
    description     VARCHAR(20)     NOT NULL,
    PRIMARY KEY (star_rating_id),
    UNIQUE KEY uq_star_code (code)
 );
 CREATE TABLE hotel_characteristic (
    characteristic_id   INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    code                VARCHAR(20)     NOT NULL,
    description         VARCHAR(100)    NOT NULL,
    PRIMARY KEY (characteristic_id),
    UNIQUE KEY uq_char_code (code)
 );
 CREATE TABLE room_type (
    room_type_id    INT UNSIGNED        NOT NULL AUTO_INCREMENT,
    code            VARCHAR(20)         NOT NULL,
    description     VARCHAR(100)        NOT NULL,
    standard_rate   DECIMAL(10,2)       NOT NULL,
    smoking_yn      BOOLEAN             NOT NULL DEFAULT FALSE,
    PRIMARY KEY (room_type_id),
    UNIQUE KEY uq_room_type_code (code)
 );
 CREATE TABLE rate_period (
    rate_period_id  INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    code            VARCHAR(20)     NOT NULL,
    description     VARCHAR(50)     NOT NULL,
    month_from      TINYINT UNSIGNED NOT NULL,
    month_to        TINYINT UNSIGNED NOT NULL,
    PRIMARY KEY (rate_period_id),
    UNIQUE KEY uq_rate_period_code (code)
 );
 -- ─────────────────────────────────────────────────────────────────────────────
 -- CORE ENTITIES
 -- ─────────────────────────────────────────────────────────────────────────────
 CREATE TABLE hotel (
    hotel_id        INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    hotel_chain_id  INT UNSIGNED,
    country_id      INT UNSIGNED    NOT NULL,
    star_rating_id  INT UNSIGNED    NOT NULL,
    code            VARCHAR(20)     NOT NULL,
    name            VARCHAR(150)    NOT NULL,
    address         VARCHAR(200),
    postcode        VARCHAR(20),
    city            VARCHAR(100)    NOT NULL,
    url             VARCHAR(200),
    PRIMARY KEY (hotel_id),
    UNIQUE KEY uq_hotel_code (code),
    CONSTRAINT fk_hotel_chain   FOREIGN KEY (hotel_chain_id) REFERENCES hotel_chain   (hotel_chain_id),
    CONSTRAINT fk_hotel_country FOREIGN KEY (country_id)    REFERENCES country        (country_id),
    CONSTRAINT fk_hotel_star    FOREIGN KEY (star_rating_id) REFERENCES star_rating   (star_rating_id)
 );
 CREATE TABLE hotel_room (
    room_id         INT UNSIGNED        NOT NULL AUTO_INCREMENT,
    hotel_id        INT UNSIGNED        NOT NULL,
    room_type_id    INT UNSIGNED        NOT NULL,
    room_number     VARCHAR(10)         NOT NULL,
    floor           TINYINT UNSIGNED    NOT NULL DEFAULT 0,
    PRIMARY KEY (room_id),
    UNIQUE KEY uq_hotel_room (hotel_id, room_number),
    CONSTRAINT fk_room_hotel    FOREIGN KEY (hotel_id)     REFERENCES hotel      (hotel_id),
    CONSTRAINT fk_room_type     FOREIGN KEY (room_type_id) REFERENCES room_type  (room_type_id)
 );
 CREATE TABLE guest (
    guest_id    INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    country_id  INT UNSIGNED,
    name        VARCHAR(150)    NOT NULL,
    email       VARCHAR(150),
    address     VARCHAR(200),
    city        VARCHAR(100),
    PRIMARY KEY (guest_id),
    CONSTRAINT fk_guest_country FOREIGN KEY (country_id) REFERENCES country (country_id)
 );
 CREATE TABLE booking (
    booking_id  INT UNSIGNED    NOT NULL AUTO_INCREMENT,
    guest_id    INT UNSIGNED    NOT NULL,
    hotel_id    INT UNSIGNED    NOT NULL,
    date_from   DATE            NOT NULL,
    date_to     DATE            NOT NULL,
    status      ENUM('confirmed', 'cancelled', 'completed', 'no_show') NOT NULL DEFAULT 'confirmed',
    created_at  DATETIME        NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (booking_id),
    CONSTRAINT fk_booking_guest FOREIGN KEY (guest_id) REFERENCES guest (guest_id),
    CONSTRAINT fk_booking_hotel FOREIGN KEY (hotel_id) REFERENCES hotel (hotel_id)
 );
 CREATE TABLE room_booking (
    room_booking_id INT UNSIGNED        NOT NULL AUTO_INCREMENT,
    booking_id      INT UNSIGNED        NOT NULL,
    room_id         INT UNSIGNED        NOT NULL,
    date_from       DATE                NOT NULL,
    date_to         DATE                NOT NULL,
    nightly_rate    DECIMAL(10,2)       NOT NULL,
    total_amount    DECIMAL(10,2)       NOT NULL,
    PRIMARY KEY (room_booking_id),
    CONSTRAINT fk_rb_booking    FOREIGN KEY (booking_id) REFERENCES booking    (booking_id),
    CONSTRAINT fk_rb_room       FOREIGN KEY (room_id)    REFERENCES hotel_room  (room_id)
 );
 -- ─────────────────────────────────────────────────────────────────────────────
 -- JUNCTION TABLES
 -- ─────────────────────────────────────────────────────────────────────────────
 CREATE TABLE hotel_hotel_characteristic (
    hotel_id            INT UNSIGNED NOT NULL,
    characteristic_id   INT UNSIGNED NOT NULL,
    PRIMARY KEY (hotel_id, characteristic_id),
    CONSTRAINT fk_hhc_hotel FOREIGN KEY (hotel_id)          REFERENCES hotel               (hotel_id),
    CONSTRAINT fk_hhc_char  FOREIGN KEY (characteristic_id) REFERENCES hotel_characteristic (characteristic_id)
 );
 CREATE TABLE period_room_rate (
    room_type_id    INT UNSIGNED    NOT NULL,
    rate_period_id  INT UNSIGNED    NOT NULL,
    rate            DECIMAL(10,2)   NOT NULL,
    PRIMARY KEY (room_type_id, rate_period_id),
    CONSTRAINT fk_prr_type   FOREIGN KEY (room_type_id)   REFERENCES room_type   (room_type_id),
    CONSTRAINT fk_prr_period FOREIGN KEY (rate_period_id) REFERENCES rate_period (rate_period_id)
 );
Author	SHA1	Message	Date
Veljko Tosic	946e4020d9	prepravljena data mart sema i generator jebemliga	2026-05-19 15:46:11 +02:00
StewKI	571c749e25	docs	2026-05-17 21:27:42 +02:00
StewKI	718407d709	nifi flow	2026-05-17 21:24:37 +02:00
StewKI	348a074a3a	datamart updated	2026-05-17 21:23:55 +02:00
StewKI	6c70628616	generate script fix	2026-05-17 21:21:43 +02:00
StewKI	e64288694b	promenjeno	2026-05-17 20:56:31 +02:00
StewKI	ee95be1031	skripte updateovane	2026-05-17 20:43:31 +02:00
StewKI	5f6251114f	generator	2026-05-17 20:43:20 +02:00
StewKI	a49013fc0c	new schemas	2026-05-17 20:32:58 +02:00
StewKI	3cd7be1e7b	nesto	2026-05-17 20:25:51 +02:00