Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Database & ORMMid25 phút đọc

Elasticsearch: analyzer, inverted index, doc values và mapping cho tìm kiếm homestay

Ôn 19 thẻ
Trong bài này

Trang tìm homestay cần tìm không dấu (“nha go da lat” ra “Nhà gỗ Đà Lạt”), lọc theo số khách, tiện ích, giá, bán kính 5 km, sắp theo khoảng cách hoặc độ liên quan, trong vài chục mili giây. Bài này giải thích Elasticsearch (ES) lưu một document thế nào, rồi thiết kế lại mapping homestay của khoá học và sửa vài chỗ sai; mọi mapping và truy vấn đã chạy trên Elasticsearch 8.15.3 (single node, Docker). Đọc xong, bạn chọn được kiểu field đúng cho từng nhu cầu và giữ ES đồng bộ với PostgreSQL.

Nên đọc trước: Thực hành EXPLAIN ANALYZE trên PostgreSQL (phần LIKE và pg_trgm), để thấy giới hạn của tìm kiếm văn bản trong database quan hệ.

1. Khi nào cần Elasticsearch

Ý chính: bắt đầu với PostgreSQL; thêm ES khi cần chấm điểm liên quan, facet, xử lý ngôn ngữ, hoặc khi tải tìm kiếm bắt đầu ảnh hưởng database giao dịch.

PostgreSQL làm được một phần (ILIKE với pg_trgm, full-text search, PostGIS). Khi dữ liệu và kiểu truy vấn tăng, một search engine là công cụ đúng việc hơn.

Trước khi kết luận PostgreSQL “không đủ”, nên thử full-text của chính nó cho đúng cách: tsvector sinh sẵn thành cột, index GIN, và cái giá phải trả khi ghi (pending list), có số đo ở Các loại index ngoài B-tree.

2. Các khái niệm

Ý chính: index chia thành shard, shard gồm nhiều segment bất biến. Document chỉ tìm được sau lần refresh kế tiếp (mặc định mỗi giây), nên ES là near real-time.

  • Index ≈ bảng, document (một JSON) ≈ dòng, mapping (kiểu và cách đánh chỉ mục của từng field) ≈ schema.
  • Shard: index chia thành các primary shard, mỗi shard là một index Lucene độc lập. Số primary shard cố định lúc tạo index.
  • Replica: bản sao của primary shard ở node khác, vừa chịu lỗi vừa phục vụ đọc.
  • Segment: file bất biến trong shard. Document mới vào bộ đệm RAM; lần refresh ghi bộ đệm thành segment mới và mở cho tìm kiếm. Refresh mỗi giây chỉ áp dụng cho index có request tìm kiếm trong 30 giây gần nhất.
  • Translog: nhật ký ghi, để không mất dữ liệu chưa flush xuống đĩa khi node chết.
  • Document bị xoá hay cập nhật chỉ được đánh dấu; segment nhỏ được merge dần ở nền.

3. Một document đi vào đâu

Ý chính: mỗi field được lưu vào cấu trúc hợp với loại truy vấn của nó: inverted index để tìm, doc values để sort và aggregate, BKD tree cho range và geo, _source để trả JSON gốc.

Vẽ lại sơ đồ của dự án khoá học:

flowchart LR
  D["Document JSON"] --> T["field text<br/>name, description"]
  D --> K["field keyword, số, ngày<br/>type, amenities, price"]
  D --> G["field geo_point<br/>location"]
  D --> S["_source<br/>JSON gốc"]
  T --> A["Analyzer<br/>char filter → tokenizer → token filter"]
  A --> II["Inverted index<br/>term → danh sách document"]
  K --> N["Normalizer (keyword, tuỳ chọn)"]
  N --> II
  K --> DV["Doc values<br/>lưu theo cột"]
  K --> BKD["BKD tree<br/>(số, ngày)"]
  G --> BKD
  G --> DV
  S --> SF["Stored fields<br/>(.fdt/.fdx)"]
Cấu trúc Lưu gì Phục vụ Field có mặc định
Inverted index (.tim, .tip, .doc, .pos) term → danh sách document, vị trí match, term, match_phrase text, keyword
BKD tree (.kdd, .kdi, .kdm) điểm nhiều chiều range trên số và ngày, geo_distance, geo_bounding_box số, date, ip, geo_point
Doc values (.dvd, .dvm) document → giá trị, theo cột sort, aggregation, script mọi kiểu trừ text
Stored fields _source (.fdt, .fdx) JSON gốc, nén trả kết quả, reindex mọi document

Inverted index giống mục lục cuối sách: mỗi từ kèm danh sách trang có nó. Tìm “đà lạt” là tra hai term rồi giao hai danh sách, không quét document nào. Nhưng nó không trả lời được “document 42 giá bao nhiêu” (phải duyệt mọi term).

Doc values giải câu hỏi ngược lại: cho document, lấy giá trị field, lưu theo cột trên đĩa. Sort theo giá, đếm theo loại, tính giá trung bình đều đọc doc values. Field text không có doc values mặc định, nên không sort hay aggregate được (mục 6).

4. Analyzer: biến văn bản thành term

Ý chính: analyzer = character filter → tokenizer → token filter, áp dụng cả lúc index lẫn lúc tìm. Analyzer standard giữ dấu tiếng Việt, nên muốn tìm không dấu phải tự thêm asciifolding.

  1. Character filter (0 hoặc nhiều): sửa chuỗi ký tự, ví dụ bỏ thẻ HTML, thay & bằng và.
  2. Tokenizer (đúng 1): cắt thành token và ghi vị trí. standard cắt theo Unicode word boundary.
  3. Token filter (0 hoặc nhiều): sửa token, ví dụ chữ thường, bỏ dấu, bỏ stop word, đồng nghĩa, stemming.

Analyzer standard chỉ có tokenizer standard và filter lowercase. So sánh bằng _analyze:

POST homestays_v1/_analyze
{ "analyzer": "standard", "text": "Nhà gỗ Đà Lạt, view đồi thông!" }
→ ["nhà", "gỗ", "đà", "lạt", "view", "đồi", "thông"]

POST homestays_v1/_analyze
{ "analyzer": "vi_folded", "text": "Nhà gỗ Đà Lạt, view đồi thông!" }
→ ["nha", "go", "da", "lat", "view", "doi", "thong"]

vi_folded là analyzer tự định nghĩa: standard + lowercase + asciifolding (đổi ký tự có dấu về ASCII, kể cả đ → d). Truy vấn “nha go da lat” trả h1 với điểm 2.647 và h2 (“Căn hộ trung tâm Đà Lạt”) với 0.918.

Chuỗi tìm kiếm cũng đi qua cùng analyzer (hoặc search_analyzer nếu khai báo riêng). Hai bên khác nhau thì term không gặp nhau.

Normalizer là bản cho keyword: không cắt token, chỉ áp filter từng ký tự như lowercase, asciifolding. Nhờ nó term trên city khớp dù dữ liệu ghi “Đà Lạt” hay “da lat”.

Nếu chính nội dung có nhiều bản dịch (tên homestay bằng tiếng Việt và tiếng Anh), mỗi ngôn ngữ nên là một field con với analyzer riêng; còn phía database lưu bản dịch bằng cột JSON hay bảng translation, fallback về ngôn ngữ mặc định ra sao, xem Case study data modeling.

5. Thiết kế mapping cho homestay

Ý chính: khai báo mapping strict, chọn kiểu theo cách dùng (tìm, lọc, sort, chỉ trả về), và để 1 shard cho index nhỏ. Mapping gốc của khoá học sai ba chỗ: float_range cho giá trung bình, mảng object không dùng nested, 2 shard cho index nhỏ.

Mapping gốc đúng hướng ở nhiều chỗ: text có subfield keyword, normalizer cho loại phòng, geo_point, ảnh index: false, mẹo nạp dữ liệu hàng loạt. Bản mình viết lại và đã chạy:

PUT homestays_v1
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 1,
    "analysis": {
      "analyzer": {
        "vi_folded": { "type": "custom", "tokenizer": "standard", "filter": ["lowercase", "asciifolding"] }
      },
      "normalizer": {
        "lower": { "type": "custom", "filter": ["lowercase", "asciifolding"] }
      }
    }
  },
  "mappings": {
    "dynamic": "strict",
    "properties": {
      "homestay_id":   { "type": "keyword" },
      "name":          { "type": "text", "analyzer": "vi_folded",
                         "fields": { "raw": { "type": "keyword", "ignore_above": 256 } } },
      "description":   { "type": "text", "analyzer": "vi_folded" },
      "type":          { "type": "keyword", "normalizer": "lower" },
      "city":          { "type": "keyword", "normalizer": "lower" },
      "nightly_price": { "type": "long" },
      "price_range":   { "type": "long_range" },
      "max_guests":    { "type": "short" },
      "location":      { "type": "geo_point" },
      "amenities":     { "type": "keyword" },
      "host": { "properties": {
        "host_id":   { "type": "keyword" },
        "name":      { "type": "text" },
        "superhost": { "type": "boolean" } } },
      "rooms": { "type": "nested", "properties": {
        "bed":    { "type": "keyword" },
        "guests": { "type": "byte" } } },
      "images":     { "type": "keyword", "index": false, "doc_values": false },
      "rating":     { "type": "scaled_float", "scaling_factor": 100 },
      "created_at": { "type": "date" }
    }
  }
}
Field / setting Lựa chọn Vì sao
dynamic strict field lạ bị từ chối (strict_dynamic_mapping_exception) thay vì ES tự đoán kiểu
homestay_id keyword chỉ tra chính xác; term trên keyword thường nhanh hơn trên số (số tối ưu cho range)
name text + name.raw keyword tìm trên name, sort và aggregate trên name.raw
nightly_price long VND không có phần lẻ
rating scaled_float, scaling_factor: 100 4.87 lưu thành 487
images index: false, doc_values: false chỉ trả về, chỉ nằm trong _source
number_of_shards 1 vài trăm nghìn homestay chỉ vài GB
Chi tiết từng lựa chọn: dynamic mapping, tiền tệ, images, kích thước shard
  • Dynamic mapping tiện khi thử nghiệm nhưng hay đoán sai (chuỗi số thành long, ngày thành text) và sinh hàng nghìn field nếu dữ liệu có key động.
  • Tiền tệ có phần lẻ: dùng scaled_float (lưu thành số nguyên sau khi nhân scaling_factor, nén tốt hơn float và không có sai số nhị phân khi so sánh) hoặc lưu đơn vị nhỏ nhất dạng long.
  • images: truy vấn lên field này bị từ chối: “Cannot search on field [images] since it is not indexed nor has doc values”.
  • Shard: tài liệu của Elastic khuyên mỗi shard 10–50 GB và dưới khoảng 200 triệu document. Nhiều shard nhỏ làm mỗi truy vấn phải hỏi nhiều shard và tốn heap cho metadata.

Range field: dùng cho khoảng, không cho một con số

Ý chính: range field lưu một khoảng (cận dưới, cận trên), chỉ hợp khi dữ liệu là khoảng: khoảng giá theo mùa, khung giờ mở cửa, dải IP. Một con số như giá trung bình phải là kiểu số.

Thí nghiệm price_range (long_range) với ba homestay

Dữ liệu: h1 700k–1,2tr, h2 500k–650k, h3 3tr–5tr.

Truy vấn trên price_range Kết quả
range 550k–800k, relation: intersects (khoảng giá giao với ngân sách) h1, h2
range 400k–1,3tr, relation: within (khoảng giá nằm trọn trong ngân sách) h1, h2
sort theo price_range giá trị sort là chuỗi byte vô nghĩa
sort theo nightly_price 600000, 850000, 3500000

Object và nested

Ý chính: Lucene không có object lồng nhau, nên object bị làm phẳng thành các field có dấu chấm. Với object đơn như host thì không sao; với mảng object, liên kết giữa các field của cùng phần tử bị mất.

Cùng dữ liệu phòng [{bed: double, guests: 2}, {bed: single, guests: 1}], lưu dạng object (rooms_flat) và dạng nested (rooms), rồi hỏi “có phòng giường đôi cho 1 khách không”:

// object: bị làm phẳng thành rooms_flat.bed = [double, single], rooms_flat.guests = [2, 1]
{ "query": { "bool": { "filter": [
  { "term": { "rooms_flat.bed": "double" } },
  { "term": { "rooms_flat.guests": 1 } } ] } } }
→ h1   (sai: không có phòng nào là giường đôi cho 1 khách)

// nested: mỗi phần tử là một document ẩn riêng
{ "query": { "nested": { "path": "rooms", "query": { "bool": { "filter": [
  { "term": { "rooms.bed": "double" } },
  { "term": { "rooms.guests": 1 } } ] } } } } }
→ (không có kết quả, đúng)
Chọn cách lưu dữ liệu con: nested, field tính sẵn hay index riêng

6. Truy vấn tìm kiếm

Ý chính: chỉ phần văn bản cần xếp hạng nằm trong must; mọi điều kiện có/không (thành phố, số khách, tiện ích, bán kính) nằm trong filter, vì filter không tính điểm và được cache.

Truy vấn chính của trang tìm kiếm, đã chạy:

GET homestays/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "name": { "query": "nhà gỗ" } } }
      ],
      "filter": [
        { "term":  { "city": "Đà Lạt" } },
        { "range": { "max_guests": { "gte": 2 } } },
        { "terms": { "amenities": ["wifi"] } },
        { "geo_distance": { "distance": "5km", "location": { "lat": 11.9416, "lon": 108.4383 } } }
      ]
    }
  },
  "sort": [
    { "_geo_distance": { "location": { "lat": 11.9416, "lon": 108.4383 }, "order": "asc", "unit": "m" } }
  ]
}

Kết quả: h1 với giá trị sort 2.180 m.

  • must tính điểm bằng BM25 (công thức chấm độ liên quan theo tần suất term); filter chỉ trả có/không và được cache theo segment.
  • term trên city khớp vì normalizer lower biến cả “Đà Lạt” trong truy vấn và “da lat” trong dữ liệu thành da lat.
  • geo_distance dùng BKD tree của geo_point, tính trên mặt cầu, nên không bị méo như đo trong hệ toạ độ Web Mercator (SRID 3857) ở dự án PostGIS gốc.
  • Facet chạy trên doc values: terms theo type ra apartment 1, cabin 1, villa 1, avg của nightly_price là 1.650.000.
Phân trang sâu: vì sao from + size dừng ở 10.000

Phòng trống theo ngày không nên nằm trong ES

Ý chính: ES lọc ứng viên và trả vài trăm id; PostgreSQL kiểm tra phòng trống theo ngày cho chính các id đó và khoá phòng khi đặt.

Dự án gốc join bảng homestay_availability (mỗi đêm một dòng) để lấy homestay còn trống mọi đêm. Lịch này đổi mỗi lần có người đặt, và mỗi thay đổi là reindex document (với nested là cả cây). Có thể đưa vào ES thông tin thô hơn (các khoảng ngày đã kín dạng date_range) để lọc bớt, miễn bước kiểm tra cuối ở database.

7. Đồng bộ dữ liệu từ PostgreSQL

Ý chính: PostgreSQL là nguồn sự thật, ES là bản sao. Tránh ghi đôi; dùng outbox hoặc CDC, và làm mỗi lần ghi vào ES an toàn khi bị lặp hay sai thứ tự.

Cách Mô tả Vấn đề
Ghi đôi (dual write) service ghi DB rồi gọi ES DB commit mà ES lỗi (hoặc ngược lại) là lệch vĩnh viễn; hai request đồng thời có thể ghi ES sai thứ tự
Outbox cùng transaction ghi DB và một dòng outbox; worker đọc outbox gửi sang ES trễ thêm một chút, cần worker
CDC (change data capture) Debezium đọc WAL của PostgreSQL, đẩy sự kiện qua Kafka, consumer ghi ES thêm Kafka và Debezium phải vận hành
  • Ghi idempotent: dùng homestay_id làm _id, ghi lại bao nhiêu lần cũng ra cùng một document.
  • External version: ghi kèm version của dòng trong DB (?version=17&version_type=external). ES từ chối bản có version nhỏ hơn hoặc bằng bản đang có, nên sự kiện cũ đến muộn không đè dữ liệu mới.

Mình đã thử: ghi version 17 thành công, sau đó ghi 16 hoặc ghi lại 17 đều nhận version_conflict_engine_exception. Consumer coi lỗi này là “đã có bản mới hơn” và bỏ qua, không retry.

Nạp lần đầu hàng triệu document bằng _bulk

Khi nạp lần đầu (như script sinh dữ liệu của khoá học), tài liệu của Elastic khuyên:

  • Dùng _bulk với lô vài MB đến vài chục MB, tăng dần kích thước tới khi throughput không tăng nữa.
  • Đặt refresh_interval: -1 và number_of_replicas: 0 trong lúc nạp, rồi trả lại sau.
  • Để ES tự sinh id nếu không cần id cố định (bỏ qua bước kiểm tra trùng id).
  • Gặp 429 thì lùi lại với exponential backoff.

Bài tập

Bài 1: Mapping cho review

Đề: thêm tính năng review: mỗi review có người viết, số sao 1–5, nội dung tiếng Việt, ngày viết. Cần tìm review theo nội dung, lọc theo số sao, và hiển thị điểm trung bình trên trang tìm kiếm homestay. Thiết kế mapping.

Lời giải Bài 1: index riêng reviews_v1

Dùng index riêng reviews_v1 (alias reviews), không nhét vào homestay dạng nested vì review nhiều và thêm liên tục:

PUT reviews_v1
{
  "settings": { "analysis": { "analyzer": {
    "vi_folded": { "type": "custom", "tokenizer": "standard", "filter": ["lowercase", "asciifolding"] } } } },
  "mappings": { "dynamic": "strict", "properties": {
    "review_id":   { "type": "keyword" },
    "homestay_id": { "type": "keyword" },
    "author_id":   { "type": "keyword" },
    "stars":       { "type": "byte" },
    "content":     { "type": "text", "analyzer": "standard",
                     "fields": { "folded": { "type": "text", "analyzer": "vi_folded" } } },
    "created_at":  { "type": "date" } } }
}

Điểm trung bình và số review tính trong PostgreSQL (hoặc bằng aggregation định kỳ) rồi ghi vào rating, review_count của document homestay, để trang tìm kiếm không phải truy vấn sang index review. content giữ dấu để xếp hạng chính xác, content.folded bỏ dấu cho người gõ không dấu. Đã chạy: multi_match “chu nha than thien” trên ["content^2", "content.folded"] tìm ra review “Phòng sạch, chủ nhà thân thiện”.

Bài 2: Vì sao homestay này lọt vào kết quả?

Đề: truy vấn “homestay có phòng cho 4 khách với giường đôi” trả về một homestay chỉ có hai phòng: {bed: double, guests: 2} và {bed: bunk, guests: 4}. Giải thích và sửa.

Lời giải Bài 2: object bị làm phẳng

rooms đang là object, bị làm phẳng thành rooms.bed = [double, bunk] và rooms.guests = [2, 4], nên “bed = double” khớp phần tử đầu và “guests = 4” khớp phần tử sau.

Sửa: đổi rooms sang nested và dùng truy vấn nested. Vì không đổi kiểu field tại chỗ được, tạo homestays_v2 với mapping mới, reindex, rồi chuyển alias. Nếu chỉ cần đúng kiểu lọc này, có thể tính sẵn field room_types kiểu keyword chứa "double:2", "bunk:4" và lọc term trên "double:4".

Bài 3: Đánh giá mapping gốc

Đề: cho mapping có avg_price kiểu float_range, host là object chứa mảng languages, 2 primary shard cho 200.000 document, title kiểu text có fields.keyword. Chỉ ra vấn đề.

Lời giải Bài 3: bốn điểm trong mapping gốc
  • avg_price là một số, phải là scaled_float hoặc long theo đơn vị nhỏ nhất, nếu không thì không sort và aggregate được.
  • host là object đơn nên object là đủ. languages là mảng giá trị đơn (keyword), không phải mảng object, nên cũng không cần nested; nested chỉ cần cho mảng object khi truy vấn nhiều field trên cùng phần tử.
  • 200.000 document chỉ vài GB: 1 primary shard (cộng replica) hợp với hướng dẫn 10–50 GB mỗi shard.
  • title với subfield keyword là đúng: tìm trên title, sort và aggregate trên title.keyword.

Ghi nhớ

  • Nói được mỗi cấu trúc (inverted index, doc values, BKD tree, _source) phục vụ loại truy vấn nào.
  • Giải thích được vì sao text không sort được và cách sửa bằng multi-field.
  • Biết khi nào phải dùng nested thay vì object, và cái giá của nó.
  • Thiết kế được luồng đồng bộ PostgreSQL → ES an toàn khi sự kiện bị lặp hay đến sai thứ tự.
  • Biết cách đổi mapping trên production không downtime.

Câu hỏi phỏng vấn

Junior

Inverted index là gì?

Là cấu trúc ánh xạ mỗi term tới danh sách document chứa nó (kèm vị trí), giống mục lục cuối sách.

Tìm một từ là tra term rồi lấy danh sách, không quét mọi document, nên full-text search nhanh. Nó không hợp để hỏi “document này có giá trị gì” (việc đó của doc values).

text và keyword khác nhau thế nào?

text qua analyzer để tìm full-text; keyword giữ nguyên cả chuỗi để lọc chính xác, sort và aggregate.

text bị cắt thành token, dùng với match. keyword có thể qua normalizer, dùng với term. Field cần cả hai thì dùng multi-field: name là text và name.raw là keyword.

Mid

Analyzer gồm những gì? Làm sao tìm không dấu tiếng Việt?

Character filter (0+) sửa chuỗi, tokenizer (đúng 1) cắt token, token filter (0+) sửa token. Tìm không dấu thì dùng lowercase + asciifolding cho cả lúc index và lúc tìm.

asciifolding đổi cả đ thành d. Nên giữ thêm field con có dấu và boost nó để kết quả có dấu đúng xếp trên, vì bỏ dấu làm nhiều từ khác nghĩa trùng nhau.

Khi nào dùng nested thay vì object?

Khi field là mảng object và cần lọc nhiều điều kiện trên cùng một phần tử.

object làm phẳng mảng nên điều kiện khớp chéo giữa các phần tử. nested lưu mỗi phần tử thành document ẩn riêng nên đúng, nhưng tốn hơn: thêm document, truy vấn chậm hơn, sửa một phần tử là reindex cả cha, có giới hạn số lượng.

must và filter trong bool khác nhau thế nào?

Cả hai đều phải khớp, nhưng chỉ must góp vào điểm liên quan; filter không tính điểm và được cache theo segment.

Điều kiện có/không (thành phố, khoảng giá, bán kính) nên nằm trong filter; chỉ phần văn bản cần xếp hạng nằm trong must.

Vì sao ghi xong mà tìm chưa thấy ngay?

Vì ES là near real-time: document mới chỉ tìm được sau lần refresh kế tiếp (mặc định mỗi giây với index đang được tìm).

Đừng ép refresh sau mỗi lần ghi vì tạo rất nhiều segment nhỏ. Nếu cần, dùng refresh=wait_for cho đúng request đó, hoặc lấy dữ liệu vừa ghi từ DB.

Senior

Đồng bộ dữ liệu từ PostgreSQL sang Elasticsearch thế nào cho đúng?

Không ghi đôi; dùng outbox hoặc CDC, ghi idempotent bằng _id = khoá chính kèm version_type=external, và có đối soát định kỳ.

  • Ghi đôi: DB commit mà ES lỗi là lệch vĩnh viễn, request đồng thời có thể ghi sai thứ tự.
  • Outbox trong cùng transaction, hoặc CDC (Debezium đọc WAL qua Kafka).
  • Version của dòng làm external version để sự kiện cũ đến muộn bị từ chối.
  • Job đối soát so số lượng hoặc checksum, và một luồng reindex toàn bộ từ DB khi cần.
Bạn cần đổi analyzer của một field trên index đang chạy production. Làm thế nào?

Không đổi tại chỗ được: tạo index mới, reindex, rồi đổi alias nguyên tử.

Ứng dụng phải đọc ghi qua alias. Tạo index version mới với mapping mới, reindex từ index cũ hoặc nạp lại từ DB; trong lúc đó luồng đồng bộ ghi cả hai index (hoặc chạy lại phần thay đổi sau thời điểm bắt đầu reindex). Kiểm tra số lượng và chất lượng tìm kiếm, đổi alias bằng _aliases, giữ index cũ một thời gian để quay lại nếu cần.

Chọn số shard cho một index thế nào?

Theo dung lượng dự kiến: mỗi shard 10–50 GB và dưới khoảng 200 triệu document; index nhỏ dùng 1 primary shard.

Nhiều shard nhỏ làm mỗi truy vấn phải hỏi nhiều shard và tốn heap cho metadata. Số primary shard cố định lúc tạo, chỉ đổi bằng split, shrink hoặc reindex, nên dữ liệu tăng theo thời gian (log, event) dùng index theo thời gian hoặc data stream với rollover. Tải đọc tăng bằng replica, không phải bằng thêm primary.

Phòng trống theo ngày có nên đưa vào Elasticsearch không?

Không nên làm nguồn quyết định: ES lọc ứng viên, PostgreSQL kiểm tra trống theo ngày và khoá khi đặt.

Lịch trống đổi mỗi lần đặt phòng, mỗi lần đổi là reindex document, và ES trễ vài giây so với DB nên có thể hiện phòng đã kín. Có thể đưa thông tin thô vào ES để lọc bớt, nhưng kiểm tra cuối cùng phải ở database.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
inverted index /ɪnˈvɜːtɪd ˈɪndeks/ chỉ mục ngược term → document “Full-text queries hit the inverted index, so they don’t scan documents.”
analyzer /ˈænəlaɪzə/ bộ xử lý văn bản thành term “We use a custom analyzer with ASCII folding for Vietnamese.”
tokenizer /ˈtəʊkənaɪzə/ bộ cắt token “The standard tokenizer splits Vietnamese by syllable, not by word.”
doc values /dɒk ˈvæljuːz/ dữ liệu lưu theo cột “Sorting and aggregations read doc values, not the inverted index.”
shard / replica /ʃɑːd/ /ˈreplɪkə/ phân mảnh / bản sao “We scale reads by adding replicas, not primary shards.”
near real-time /nɪə rɪəl taɪm/ gần thời gian thực “Elasticsearch is near real-time: new documents show up after the next refresh.”
relevance score /ˈreləvəns skɔː/ điểm liên quan “Filters don’t affect the relevance score, and they’re cached.”
nested document /ˈnestɪd ˈdɒkjʊmənt/ document con ẩn “Each nested object is indexed as a hidden Lucene document.”
alias /ˈeɪliəs/ tên thay thế trỏ tới index “The app talks to an alias, so we can swap indices without downtime.”
facet /ˈfæsɪt/ bộ lọc kèm số đếm “The facets on the left come from terms aggregations.”
ASCII folding /ˈæski ˈfəʊldɪŋ/ bỏ dấu về chữ ASCII “ASCII folding lets users search without diacritics.”
change data capture /tʃeɪndʒ ˈdeɪtə ˈkæptʃə/ bắt thay đổi từ log của DB “We keep the index in sync with change data capture from the WAL.”

Tham khảo


Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.