Add chapter-09-multimodel-integration/README.md

chapter-09-multimodel-integration/README.md

@@ -0,0 +1,364 @@
+# Chương 9: Tích hợp Dữ liệu Đa mô hình và CSDL Hiện đại
+## Multi-model Data Integration & Modern Databases
+
+---
+
+## 📚 Mục tiêu học tập (CLO5, CLO6, CLO8, CLO9)
+
+Sau khi hoàn thành chương này, sinh viên có thể:
+- Hiểu kiến trúc Polyglot Persistence và khi nào cần multi-model
+- Tích hợp Knowledge Graph vào DWH
+- Xử lý Vector data cho semantic search
+- Hiểu Blockchain cho data integrity
+- Implement Federated Querying across multiple engines
+
+---
+
+## 9.1. Kiến trúc Polyglot Persistence
+
+```
+    ┌──────────────────────────────────────────────────────────────┐
+    │              POLYGLOT PERSISTENCE                             │
+    │                                                              │
+    │  "Dùng đúng database cho đúng use case"                     │
+    │                                                              │
+    │  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐      │
+    │  │Relational│ │ Document │ │  Graph   │ │  Vector  │      │
+    │  │(Postgres)│ │ (Mongo)  │ │  (Neo4j) │ │ (Chroma) │      │
+    │  │          │ │          │ │          │ │          │      │
+    │  │ Orders   │ │ Product  │ │ Customer │ │ Review   │      │
+    │  │ Payments │ │ Catalog  │ │ Network  │ │ Embeddings│      │
+    │  │ Star     │ │ (nested  │ │ (social, │ │ Semantic │      │
+    │  │ Schema   │ │  JSON)   │ │  product │ │ Search   │      │
+    │  │          │ │          │ │  graph)  │ │          │      │
+    │  └──────────┘ └──────────┘ └──────────┘ └──────────┘      │
+    │       │              │            │            │             │
+    │       └──────────────┼────────────┼────────────┘             │
+    │                      │            │                          │
+    │              ┌───────▼────────────▼──────┐                  │
+    │              │  Unified Query Engine      │                  │
+    │              │  (Presto/Trino/Spark)      │                  │
+    │              └───────────────────────────┘                  │
+    └──────────────────────────────────────────────────────────────┘
+    
+    Database Types Summary:
+    ┌──────────────┬───────────────┬──────────────────────────┐
+    │ Type         │ Best for      │ Examples                 │
+    ├──────────────┼───────────────┼──────────────────────────┤
+    │ Relational   │ ACID, Joins   │ PostgreSQL, MySQL        │
+    │ Document     │ Flexible JSON │ MongoDB, DynamoDB        │
+    │ Key-Value    │ Fast lookup   │ Redis, Memcached         │
+    │ Column-family│ Time series   │ ClickHouse, Cassandra    │
+    │ Graph        │ Relationships │ Neo4j, Amazon Neptune    │
+    │ Vector       │ Similarity    │ ChromaDB, Pinecone       │
+    │ Time series  │ Temporal data │ InfluxDB, TimescaleDB    │
+    └──────────────┴───────────────┴──────────────────────────┘
+```
+
+---
+
+## 9.2. Knowledge Graph
+
+### Tích hợp Graph Database cho Olist
+
+```
+    Olist Knowledge Graph:
+    
+    (Customer:C001) ──[PLACED]──→ (Order:O001)
+         │                            │
+         │                       [CONTAINS]
+    [LIVES_IN]                        │
+         │                    (Product:P001)
+         ▼                       │         │
+    (City:SaoPaulo)        [BELONGS_TO] [SOLD_BY]
+         │                       │         │
+    [IN_STATE]            (Category:   (Seller:S001)
+         │                Beauty)         │
+         ▼                          [LOCATED_IN]
+    (State:SP)                          │
+                                   (City:Curitiba)
+    
+    Graph Queries (Cypher):
+    
+    -- Tìm sản phẩm thường mua cùng
+    MATCH (p1:Product)<-[:CONTAINS]-(o:Order)-[:CONTAINS]->(p2:Product)
+    WHERE p1.id <> p2.id
+    RETURN p1.category, p2.category, COUNT(*) AS co_purchase
+    ORDER BY co_purchase DESC
+    LIMIT 10;
+    
+    -- Customer journey analysis
+    MATCH path = (c:Customer)-[:PLACED]->(o:Order)-[:CONTAINS]->(p:Product)
+    WHERE c.id = 'C001'
+    RETURN path;
+    
+    -- Seller performance network
+    MATCH (s:Seller)-[:SOLD]->(p:Product)<-[:REVIEWED {score: 1}]-(c:Customer)
+    RETURN s.id, COUNT(*) AS bad_reviews
+    ORDER BY bad_reviews DESC;
+```
+
+---
+
+## 9.3. Vector Data & Indexing
+
+### Kỹ thuật lập chỉ mục cho dữ liệu chiều cao
+
+```
+    Vector Indexing Methods:
+    
+    1. Flat (Brute-force):
+       - Compare query with EVERY vector
+       - Exact results but O(n*d)
+       - Good for < 10K vectors
+    
+    2. IVF (Inverted File Index):
+       ┌──────┐   ┌──────┐   ┌──────┐
+       │Cell 1│   │Cell 2│   │Cell 3│  ← Voronoi cells
+       │ . .  │   │ . .  │   │ .    │
+       │  .   │   │ . .  │   │ . .  │
+       └──────┘   └──────┘   └──────┘
+       Query → Find nearest cell → Search within cell
+       → Approximate but much faster
+    
+    3. HNSW (Hierarchical Navigable Small World):
+       Layer 3:  O ─────────── O
+       Layer 2:  O ── O ────── O ── O
+       Layer 1:  O─O─O─O──O─O─O─O─O─O
+       Layer 0:  OOOOOOOOOOOOOOOOOOOOOO
+       → Navigate from top layer down
+       → Best for high-dimensional, large-scale
+    
+    4. PQ (Product Quantization):
+       Vector [1.2, 0.5, -0.3, ...] → Compressed [3, 7, 1, ...]
+       → Lossy compression, trades accuracy for speed+memory
+    
+    Distance Metrics:
+    - Cosine Similarity: cos(θ) = A·B / (|A|*|B|)  → Semantic similarity
+    - Euclidean (L2): √Σ(ai-bi)²                    → Geometric distance
+    - Inner Product (IP): A·B                         → Raw dot product
+```
+
+### pgvector Example (PostgreSQL)
+
+```sql
+-- Enable pgvector extension
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- Create table with vector column
+CREATE TABLE review_embeddings (
+    review_id VARCHAR(50) PRIMARY KEY,
+    review_text TEXT,
+    embedding VECTOR(384),  -- 384-dim embedding
+    review_score SMALLINT
+);
+
+-- Create HNSW index
+CREATE INDEX ON review_embeddings 
+USING hnsw (embedding vector_cosine_ops);
+
+-- Semantic search: Find reviews similar to "delivery was late"
+SELECT review_id, review_text, review_score,
+       1 - (embedding <=> '[0.1, -0.3, ...]'::vector) AS similarity
+FROM review_embeddings
+ORDER BY embedding <=> '[0.1, -0.3, ...]'::vector
+LIMIT 10;
+```
+
+---
+
+## 9.4. Blockchain cho Data Integrity
+
+```
+    Blockchain Audit Trail:
+    
+    ┌───────────┐    ┌───────────┐    ┌───────────┐    ┌───────────┐
+    │ Block #1  │───→│ Block #2  │───→│ Block #3  │───→│ Block #4  │
+    │           │    │           │    │           │    │           │
+    │ prev: 0x0 │    │ prev: 0xa│    │ prev: 0xb│    │ prev: 0xc│
+    │ hash: 0xa │    │ hash: 0xb│    │ hash: 0xc│    │ hash: 0xd│
+    │           │    │           │    │           │    │           │
+    │ Data:     │    │ Data:     │    │ Data:     │    │ Data:     │
+    │ Schema v1 │    │ ETL run   │    │ Model v2  │    │ Access    │
+    │ created   │    │ 5000 rows │    │ deployed  │    │ by user X │
+    │           │    │ loaded    │    │ AUC=0.85  │    │ at 14:30  │
+    └───────────┘    └───────────┘    └───────────┘    └───────────┘
+    
+    Immutable! Nếu ai sửa Block #2 → hash thay đổi → 
+    Block #3 prev hash không khớp → Chain broken → Tamper detected!
+    
+    Use cases trong DWH:
+    1. Metadata Audit Logs: Ai thay đổi schema, khi nào
+    2. Data Provenance: Chứng minh data không bị sửa
+    3. Compliance: Regulatory audit trail (AI Act)
+    4. Data Sharing: Verify data integrity khi share cross-org
+```
+
+---
+
+## 9.5. Blockchain for Data Integrity
+
+### Implementation Pattern
+
+```python
+import hashlib
+import json
+from datetime import datetime
+
+class AuditBlock:
+    def __init__(self, index, data, previous_hash):
+        self.index = index
+        self.timestamp = datetime.now().isoformat()
+        self.data = data
+        self.previous_hash = previous_hash
+        self.hash = self.calculate_hash()
+    
+    def calculate_hash(self):
+        block_string = json.dumps({
+            'index': self.index,
+            'timestamp': self.timestamp,
+            'data': self.data,
+            'previous_hash': self.previous_hash
+        }, sort_keys=True)
+        return hashlib.sha256(block_string.encode()).hexdigest()
+
+class AuditChain:
+    def __init__(self):
+        self.chain = [self._create_genesis_block()]
+    
+    def _create_genesis_block(self):
+        return AuditBlock(0, {"event": "Chain initialized"}, "0")
+    
+    def add_event(self, event_data):
+        previous_block = self.chain[-1]
+        new_block = AuditBlock(
+            len(self.chain), event_data, previous_block.hash
+        )
+        self.chain.append(new_block)
+        return new_block
+    
+    def verify_integrity(self):
+        for i in range(1, len(self.chain)):
+            current = self.chain[i]
+            previous = self.chain[i-1]
+            
+            if current.hash != current.calculate_hash():
+                return False, f"Block {i} hash tampered"
+            if current.previous_hash != previous.hash:
+                return False, f"Block {i} chain broken"
+        
+        return True, "Chain integrity verified"
+```
+
+---
+
+## 9.6. Federated Querying
+
+```
+    ┌──────────────────────────────────────────────────┐
+    │              FEDERATED QUERY ENGINE               │
+    │              (Trino / Presto / Spark)             │
+    │                                                    │
+    │  SELECT c.name, o.total, g.label                  │
+    │  FROM postgres.orders o                           │
+    │  JOIN neo4j.customer_graph g ON o.cust = g.id     │
+    │  JOIN clickhouse.realtime r ON o.id = r.order_id  │
+    │                                                    │
+    │  → 1 SQL query across 3 databases!                │
+    └───────────┬───────────┬───────────┬──────────────┘
+                │           │           │
+         ┌──────▼──┐  ┌────▼────┐  ┌──▼─────────┐
+         │Postgres │  │  Neo4j  │  │ ClickHouse │
+         │(Star    │  │(Graph)  │  │(Real-time) │
+         │ Schema) │  │         │  │            │
+         └─────────┘  └─────────┘  └────────────┘
+    
+    Trino Catalog Configuration:
+    
+    # PostgreSQL catalog
+    connector.name=postgresql
+    connection-url=jdbc:postgresql://host:5432/olist_dw
+    
+    # ClickHouse catalog  
+    connector.name=clickhouse
+    connection-url=jdbc:clickhouse://host:8123/realtime_db
+```
+
+---
+
+## 9.7. Multi-model Query Optimization
+
+```
+    Optimization Strategies:
+    
+    1. Pushdown Predicates:
+       → Push WHERE clauses to source databases
+       → Reduce data transfer
+    
+    2. Join Ordering:
+       → Join smaller tables first
+       → Use broadcast join for small dims
+    
+    3. Materialized Views:
+       → Pre-compute cross-database joins
+       → Refresh on schedule
+    
+    4. Caching:
+       → Cache frequently accessed data
+       → Time-based invalidation
+```
+
+---
+
+## 9.8. High Availability & Disaster Recovery
+
+```
+    HA/DR Architecture:
+    
+    Region A (Primary)           Region B (Secondary)
+    ┌────────────────┐          ┌────────────────┐
+    │  App Servers   │          │  App Servers   │
+    │  (Active)      │          │  (Standby)     │
+    │                │          │                │
+    │  ┌──────────┐  │  Sync   │  ┌──────────┐  │
+    │  │ Primary  │──┼────────→│  │ Replica  │  │
+    │  │ DB       │  │  Async  │  │ DB       │  │
+    │  └──────────┘  │         │  └──────────┘  │
+    │                │         │                │
+    │  ┌──────────┐  │  Sync   │  ┌──────────┐  │
+    │  │ Object   │──┼────────→│  │ Object   │  │
+    │  │ Storage  │  │         │  │ Storage  │  │
+    │  └──────────┘  │         │  └──────────┘  │
+    └────────────────┘         └────────────────┘
+    
+    RPO (Recovery Point Objective): How much data can you lose?
+    RTO (Recovery Time Objective): How fast must you recover?
+    
+    ┌────────────────────────────────────────────┐
+    │ Strategy       │ RPO        │ RTO          │
+    ├────────────────┼────────────┼──────────���───┤
+    │ Backup/Restore │ Hours      │ Hours        │
+    │ Warm Standby   │ Minutes    │ Minutes      │
+    │ Hot Standby    │ Seconds    │ Seconds      │
+    │ Active-Active  │ Zero       │ Zero         │
+    └────────────────┴────────────┴──────────────┘
+```
+
+---
+
+## 🔬 Labs
+
+- [`lab-09-knowledge-graph.py`](lab-09-knowledge-graph.py) — Knowledge Graph cho Olist
+- [`lab-09-vector-search.py`](lab-09-vector-search.py) — Vector Search & pgvector
+- [`lab-09-blockchain-audit.py`](lab-09-blockchain-audit.py) — Blockchain Audit Trail
+- [`lab-09-federated-query.py`](lab-09-federated-query.py) — Federated Querying
+
+---
+
+## 📝 Câu hỏi ôn tập
+
+1. Polyglot Persistence là gì? Cho 4 ví dụ database type phù hợp cho 4 use case khác nhau trong Olist.
+2. Knowledge Graph biểu diễn dữ liệu Olist như thế nào? Viết 2 Cypher queries.
+3. So sánh 4 phương pháp Vector Indexing (Flat, IVF, HNSW, PQ).
+4. Blockchain đảm bảo data integrity như thế nào? Giải thích hash chain.
+5. Federated Query có ưu điểm gì? Trade-off là gì?