This is an automated email from the ASF dual-hosted git repository.

morningman pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris-website.git


The following commit(s) were added to refs/heads/master by this push:
     new 3385bce4672 [blog] Add JD.com, CDC, and HubSpot posts and update 
roadmap dates (#4679)
3385bce4672 is described below

commit 3385bce4672ec271e2f5bb545314fd18d2ae6ca9
Author: Mingyu Chen (Rayner) <[email protected]>
AuthorDate: Fri Nov 20 18:29:37 2026 +0800

    [blog] Add JD.com, CDC, and HubSpot posts and update roadmap dates (#4679)
    
    Add complete English blog posts covering JD.com's lakehouse query
    optimizations, Apache Doris 5.0 CDC, and HubSpot's CRM analytics
    deployment across 33 clusters. Store compressed covers, figures, and
    video posters locally, and add the HubSpot videos and attribution tip
    boxes.
    
    Make HubSpot the lead featured post and JD.com the second featured post.
    Update the roadmap to schedule Doris 4.2 for November 2026 and Doris 5.0
    for February 2027, including the existing Chinese, Japanese, Korean, and
    Russian date translations.
    
    Synchronize manual publication metadata after reviewing the two changed
    date entries in each shared dictionary: refresh 88 target digests, and
    update source digests only for the four reviewed roadmap translations.
    
    ## Versions
    
    - [ ] dev
    - [ ] 4.x
    - [ ] 3.x
    - [ ] 2.1 or older (not covered by version/language sync gate)
    
    Not applicable: this PR changes blog content and the shared community
    roadmap page, not versioned documentation.
    
    ## Languages
    
    - [x] Chinese
    - [x] English
    
    The new posts are English-only, following the first-party blog guide and
    existing locale fallback behavior. Roadmap dates are synchronized across
    all existing locale catalogs, including Japanese, Korean, and Russian.
    
    ## Docs Checklist
    
    - [x] Checked by AI
    - [ ] Test Cases Built
    - [x] Updated required version and language counterparts, or explained
    why not
    - [x] If only one language changed, confirmed whether source/translation
    counterparts need sync
    
    ## Validation
    
    - Passed the full manual-content/shared-message validation step, all
    three locale admission checks, and the six existing manual-drift/report
    tests.
    - Passed Docusaurus Markdown/MDX compilation, metadata and heading
    checks, image-reference checks, and external-link checks.
    - Verified the featured order, tip boxes, HubSpot video embeds and
    posters, desktop/mobile rendering, and updated roadmap dates in the
    development server.
    - Parsed all changed locale JSON files and passed `git diff --check`.
    - No new test cases were added for these content and date changes. No
    production build was run, as directed by `doc-tools/HOW-TO-ADD-BLOG.md`.
    
    ---------
    
    Co-authored-by: morningman <[email protected]>
---
 blog/apache-doris-5-cdc-changelog.md               | 537 +++++++++++++++++++++
 .../apache-doris-5-multimodal-lakehouse-preview.md |   2 -
 blog/apache-doris-lance-physical-ai-analytics.md   |   2 -
 blog/hubspot-apache-doris-search-analytics.mdx     | 273 +++++++++++
 ...jd-apache-doris-lakehouse-query-optimization.md | 169 +++++++
 i18n/ja/code.json                                  |   4 +-
 i18n/ko/code.json                                  |   4 +-
 i18n/ru/code.json                                  |   4 +-
 i18n/zh-CN/code.json                               |   8 +-
 .../community-roadmap/CommunityRoadmap.tsx         |   4 +-
 .../apache-doris-5-cdc-changelog/atomic-write.jpg  | Bin 0 -> 96775 bytes
 .../campaign-spend-ivm.jpg                         | Bin 0 -> 104954 bytes
 .../campaign-spend-table-stream.jpg                | Bin 0 -> 94231 bytes
 .../changelog-read-modes.jpg                       | Bin 0 -> 139594 bytes
 .../connector-architecture.jpg                     | Bin 0 -> 104775 bytes
 .../blogs/apache-doris-5-cdc-changelog/cover.jpg   | Bin 0 -> 63320 bytes
 .../doris-flink-cdc.jpg                            | Bin 0 -> 100722 bytes
 .../apache-doris-5-cdc-changelog/exactly-once.jpg  | Bin 0 -> 105526 bytes
 .../parallel-readers.jpg                           | Bin 0 -> 94708 bytes
 .../product-price-cdc.jpg                          | Bin 0 -> 119420 bytes
 .../tso-commit-order.jpg                           | Bin 0 -> 75840 bytes
 .../wait-before-read.jpg                           | Bin 0 -> 111036 bytes
 .../cell-architecture.jpg                          | Bin 0 -> 120252 bytes
 .../cover.jpg                                      | Bin 0 -> 68397 bytes
 .../crm-data-model.jpg                             | Bin 0 -> 130108 bytes
 .../crm-query-challenges.jpg                       | Bin 0 -> 51250 bytes
 .../doris-capabilities.jpg                         | Bin 0 -> 89193 bytes
 .../global-rollout.jpg                             | Bin 0 -> 47517 bytes
 .../p50-query-latency.jpg                          | Bin 0 -> 79822 bytes
 .../priority-ingestion.jpg                         | Bin 0 -> 91120 bytes
 .../query-fan-out.jpg                              | Bin 0 -> 116581 bytes
 .../talk-video-poster.jpg                          | Bin 0 -> 112373 bytes
 .../variant-typed-columns.jpg                      | Bin 0 -> 115785 bytes
 .../video-poster.jpg                               | Bin 0 -> 94039 bytes
 .../architecture-evolution.png                     | Bin 0 -> 72046 bytes
 .../cover.jpg                                      | Bin 0 -> 61227 bytes
 .../partition-pruning.png                          | Bin 0 -> 156217 bytes
 .../pull-push-comparison.png                       | Bin 0 -> 107860 bytes
 .../scan-and-execution.png                         | Bin 0 -> 162769 bytes
 .../shared-file-listing.png                        | Bin 0 -> 161821 bytes
 .../split-scheduling.png                           | Bin 0 -> 89763 bytes
 translations/pages/state.json                      | 184 +++----
 42 files changed, 1083 insertions(+), 108 deletions(-)

diff --git a/blog/apache-doris-5-cdc-changelog.md 
b/blog/apache-doris-5-cdc-changelog.md
new file mode 100644
index 00000000000..de0fee1af4e
--- /dev/null
+++ b/blog/apache-doris-5-cdc-changelog.md
@@ -0,0 +1,537 @@
+---
+title: 'Streaming Changes out of Doris: CDC and Incremental Computing in 
Apache Doris 5.0'
+summary: 'Explore how Doris 5.0 Changelog records row changes, how Flink Doris 
Connector reads them, and how IVM and Table Stream prepare changes for 
downstream systems.'
+description: 'A technical preview of Apache Doris 5.0 CDC: Changelog read 
modes, atomic writes, TSO ordering, retention, Flink recovery and delivery 
semantics, with advertising and product-price examples.'
+keywords:
+  - 'Apache Doris 5.0'
+  - 'change data capture'
+  - 'Changelog'
+  - 'Flink Doris Connector'
+  - 'incremental view maintenance'
+  - 'Table Stream'
+date: '2026-11-12'
+author: 'Apache Doris · Mingyu Chen'
+tags:
+  - 'Tech Sharing'
+image: '/images/blogs/apache-doris-5-cdc-changelog/cover.jpg'
+---
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+*By Mingyu Chen, Apache Doris PMC Chair. Adapted from the [original 
article](https://selectdb.com/blog/doris-apache-doris-5-0-cdc), published on 
November 12, 2026.*
+
+> This is the second article in the Apache Doris 5.0 incremental computing 
preview. The [first article](/blog/apache-doris-5-incremental-computing) 
introduced the framework through business scenarios. This article examines how 
Changelog captures changes and how Flink Doris Connector delivers them 
downstream, then shows how IVM and Table Stream can prepare those changes 
inside Doris.
+
+**These capabilities are a preview of Doris 5.0.** Changelog, Table Stream, 
and IVM are experimental and require explicit configuration. The examples 
target Doris 5.0.0+ and Flink Doris Connector 26.4.0+; preview use requires 
builds containing the relevant changes.
+
+Doris has often been the last stop in a real-time warehouse pipeline. Changes 
from operational databases arrive through Flink CDC, Routine Load, or Stream 
Load, become metrics and denormalized tables, and serve reports and 
applications.
+
+Increasingly, teams use Doris as an intermediate computation engine. An 
advertising platform aggregates campaign spend in Doris and sends the results 
to its serving system for budget control. An e-commerce platform merges product 
data from several pipelines and synchronizes prices to a search engine. Data 
teams share processed tables and metrics with other business systems and data 
lakes. **Downstream systems need timely, accurate changes to the results 
computed in Doris.**
+
+Previously, teams had three common approaches:
+
+- Periodically export the entire result and compare it, with high latency and 
cost.
+- Export rows by an `update_time` column, which misses deletes.
+- Reimplement the processing in Flink, maintaining the same logic in two 
systems.
+
+Doris 5.0 introduces Changelog into its storage format to record inserts, 
updates, and deletes as data is written, with optional before images. 
Interfaces expose those changes for further processing and downstream 
consumption. This article explains the implementation and its tradeoffs.
+
+## 1. Changelog: recording changes in a distributed column store
+
+A single-node database such as MySQL can append its binlog on one machine in 
commit order. Doris distributes data across many tablets on many machines, with 
several replicas per tablet and high write throughput. Its change log must 
answer three questions:
+
+- How do change records stay consistent with the data?
+- How is change order represented across a distributed system?
+- How can changes be recorded and read efficiently?
+
+### 1.1 Three read modes: DETAIL, MIN_DELTA, and APPEND_ONLY
+
+Enable Changelog with the table property `changelog.enable` when creating a 
table. Duplicate Key tables and Unique Key Merge-on-Write tables support it. A 
Unique Key table can also enable `changelog.need_historical_value` to retain 
the old row, or **before image**, for an update. An update can then become a 
pair of Flink change events: `-U` and `+U`.
+
+Before trying the examples, set `enable_feature_changelog = true` in `fe.conf` 
on every FE and restart the FEs. Set the same option in `be.conf` and restart 
the BEs for automatic cleanup. For Table Stream and IVM, also set 
`enable_table_stream = true` on every FE. See the [Changelog prerequisites and 
limitations](https://doris.apache.org/docs/dev/data-operate/incremental/changelog/).
+
+The order examples use a table with before images enabled:
+
+```sql
+CREATE DATABASE IF NOT EXISTS shop;
+USE shop;
+
+CREATE TABLE orders (
+    order_id BIGINT,
+    status   VARCHAR(16)
+)
+UNIQUE KEY (order_id)
+DISTRIBUTED BY HASH(order_id) BUCKETS 1
+PROPERTIES (
+    "replication_num" = "1",
+    "enable_unique_key_merge_on_write" = "true",
+    "changelog.enable" = "true",
+    "changelog.need_historical_value" = "true"
+);
+```
+
+Append `@incr` to the table name and specify a time window and read mode to 
query changes like a table. The examples below illustrate a historical 
five-minute window; when experimenting, substitute recent timestamps and writes 
within your Changelog retention period. Windows are **start-inclusive and 
end-exclusive**.
+
+Assume that between 10:00 and 10:05:
+
+- Order 1000, shipped before 10:00, is confirmed delivered.
+- Order 1001 is created and then paid.
+- Order 1002 is inserted as a duplicate order and then deleted.
+
+![The same change window produces every change in DETAIL, net changes in 
MIN_DELTA, or insert events in 
APPEND_ONLY](/images/blogs/apache-doris-5-cdc-changelog/changelog-read-modes.jpg)
+
+*Figure 1. DETAIL suits auditing and risk analysis; MIN_DELTA suits state 
synchronization; APPEND_ONLY suits logs and event streams.*
+
+#### DETAIL: keep every change
+
+Auditing, risk analysis, and order lifecycle analysis need individual 
transitions. Read the window in `DETAIL` mode:
+
+```sql
+SELECT __DORIS_CHANGELOG_OP__ AS op, order_id, status
+FROM orders@incr(
+    'startTimestamp' = '2026-11-11 10:00:00',
+    'endTimestamp'   = '2026-11-11 10:05:00',
+    'incrementType'  = 'DETAIL'
+)
+ORDER BY __DORIS_CHANGELOG_TSO__, __DORIS_CHANGELOG_LSN__, op;
+```
+
+The window contains seven records. The following table groups them by order 
for readability:
+
+| op | order_id | status |
+| --- | --- | --- |
+| -U | 1000 | shipped |
+| +U | 1000 | delivered |
+| +I | 1001 | pending |
+| -U | 1001 | pending |
+| +U | 1001 | paid |
+| +I | 1002 | pending |
+| -D | 1002 | pending |
+
+The query returns numeric operation codes: `0` means insert (`+I`), `1` delete 
(`-D`), `2` update-before (`-U`), and `3` update-after (`+U`). Tables in this 
article use the symbolic forms. These are the codes exposed by `@incr`; the raw 
`changelog()` table function has a different operation-code mapping.
+
+#### MIN_DELTA: keep only net changes
+
+Some consumers need only final state. A support system or search index does 
not need order 1001's intermediate `pending` state. Order 1002 was both created 
and deleted, leaving no net change.
+
+Changing `incrementType` to `MIN_DELTA` collapses multiple changes to a key 
within the window. The seven records become three:
+
+| op | order_id | status |
+| --- | --- | --- |
+| -U | 1000 | shipped |
+| +U | 1000 | delivered |
+| +I | 1001 | paid |
+
+- Order 1000 existed at the start, so its net change is an update.
+- Order 1001 did not exist at the start, so its net change is an insert with 
status `paid`.
+- Order 1002 exists at neither boundary, so it produces no output.
+
+**Doris performs this consolidation**, reducing intermediate states and 
redundant updates sent downstream.
+
+> MIN_DELTA requires before images on Unique Key tables because it needs the 
value at the start of the window. Section 1.5 explains why.
+
+#### APPEND_ONLY: read insert events
+
+For logs, tracking events, or consumers interested only in newly inserted 
rows, use `APPEND_ONLY`:
+
+| op | order_id | status |
+| --- | --- | --- |
+| +I | 1001 | pending |
+| +I | 1002 | pending |
+
+Order 1000 has only an update, so it produces no output. Order 1002's insert 
is still emitted even though the order is later deleted.
+
+The differences among these modes apply to Unique Key tables. Duplicate Key 
tables record appended rows, so all three modes produce the same insert events. 
Deletes implemented through delete predicates on Duplicate Key tables do not 
produce Changelog events.
+
+See [Incremental 
Query](https://doris.apache.org/docs/dev/data-operate/incremental/incremental-query/)
 for the complete `@incr` syntax and output columns.
+
+### 1.2 Generating Changelog atomically with data
+
+![Each replica writes a data tablet and companion Changelog tablet on the same 
local disk, making both visible through the load 
transaction](/images/blogs/apache-doris-5-cdc-changelog/atomic-write.jpg)
+
+*Figure 2. Data files and change records become visible together through the 
load transaction.*
+
+- **Companion tablets:** Every data tablet has a Changelog tablet. Each 
replica writes data files and change records together. When before images are 
needed, the old row is looked up locally. The load transaction makes both sets 
of files visible together, or neither.
+- **Per-load consolidation:** Unique Key tables record changes per key per 
load. If the same key is written several times within one load, Changelog 
records the final result. Duplicate Key tables record every inserted row.
+- **Concurrent writes:** When several loads modify the same key, an earlier 
lookup may return an outdated old value. Changelog reuses the Unique Key 
table's write-conflict handling. If a conflict is detected at commit, affected 
records are corrected against the latest version so the before image matches 
the row's actual preceding version.
+
+> Operations that replace or remove whole datasets, such as `TRUNCATE`, 
dropping or replacing partitions, and `INSERT OVERWRITE`, do not emit a delete 
event for every removed row. Dependent materialized views may need rebuilding, 
and downstream replicas of current table state need a new full synchronization. 
Append-only processing, such as the Table Stream example in Section 3.1, 
intentionally accumulates arrivals independently of later base-table removal.
+
+### 1.3 Ordering changes with TSO and LSN
+
+Doris's original data versions increase independently within each partition. 
They cannot establish order across partitions or tables. Time-window reads need 
a shared clock: **TSO, or Timestamp Oracle**.
+
+![The Master FE assigns increasing commit timestamps across tables and 
partitions, mapping adjacent time windows to contiguous TSO 
ranges](/images/blogs/apache-doris-5-cdc-changelog/tso-commit-order.jpg)
+
+*Figure 3. The Master FE allocates TSO at commit. Adjacent time windows map to 
contiguous ranges without overlap or gaps.*
+
+- **One allocator, monotonically increasing values:** The Master FE allocates 
TSO. High bits contain physical time in milliseconds; low bits count commits 
within the same millisecond. Values do not move backward after a master change 
or clock rollback. Physical time lets a window such as 10:00–10:05 map to a TSO 
range.
+- **One TSO per transaction, allocated at commit:** Allocating it at 
transaction start would misplace long-running loads. A transaction beginning at 
10:00 and committing at 10:30 must not appear in a 10:00 window that consumers 
have already finished.
+- **Wait for visibility before reading:** Receiving a TSO does not immediately 
make the data readable. A transaction committed at 10:04 belongs to `[10:00, 
10:05)` even if publication finishes after 10:05. Reading too early would miss 
it, and the next window would exclude it. Doris therefore waits for the 
relevant transactions to become visible before reading. A timeout returns an 
error so the consumer can retry the same window.
+
+![Reading before a 10:04 commit becomes visible can lose it permanently; 
waiting for Publish allows the original time window to be read 
completely](/images/blogs/apache-doris-5-cdc-changelog/wait-before-read.jpg)
+
+*Figure 4. Commit time determines the window; visibility determines when it is 
safe to read that window.*
+
+Rows changed in the same transaction share a TSO. LSN provides a sequence 
number to order those change records. A row carries the same LSN to every 
replica, so replicas record the same change order.
+
+### 1.4 Retention and cleanup
+
+Changelog retains records for **one day by default**, controlled by 
`changelog.ttl_seconds`. Expired records become unavailable to queries 
immediately; background cleanup reclaims their storage later.
+
+TTL depends on time, not consumer progress. Consumers do not need registration 
and do not block each other's retention. The tradeoff is that slow consumers 
can lose required history:
+
+- `DETAIL` and `APPEND_ONLY` skip expired portions of a requested window 
without reporting an expiration error.
+- `MIN_DELTA` and IVM fail if the required starting history has expired, 
because they cannot compute a correct net change without it.
+
+**Retention must cover the initial snapshot duration, the longest expected 
outage, and catch-up time after recovery**, with margin. Monitor consumer lag; 
a running job alone does not establish that no history has expired.
+
+### 1.5 Reading and consolidating changes
+
+**Prune by time.** Change files carry TSO ranges. Reads skip files outside the 
requested range rather than scanning the entire Changelog.
+
+**Consolidate MIN_DELTA.** For each key, Doris considers the first and last 
change within the window. The before image of the first record supplies the 
starting value; the after image of the last record supplies the ending value.
+
+| State at start | State at end | Output |
+| --- | --- | --- |
+| Absent | Present | Insert (`+I`) |
+| Present | Absent | Delete (`-D`) |
+| Absent | Absent | None |
+| Present | Present, different row | Update-before and update-after (`-U`, 
`+U`) |
+| Present | Present, identical row | None |
+
+Before images avoid a separate lookup of historical table data. This is why 
MIN_DELTA needs them. Comparison covers the **whole row**: a change in any 
column counts as an update.
+
+**Track internal and external consumption differently.** Table Stream and IVM 
maintain TSO positions for each base-table partition. Processing results and 
new positions commit in one Doris transaction and roll back together on 
failure. External systems cannot participate in that transaction; they read 
time windows and save their own progress. Flink Doris Connector is one such 
consumer.
+
+### 1.6 Costs and limitations
+
+Changelog adds writes and storage. Enabling before images also adds old-row 
lookups, reducing ingestion throughput by an amount that depends on table 
structure and update frequency. Append-only workloads can avoid those lookups 
with Duplicate Key tables or without before images.
+
+Changelog can currently be enabled only at table creation. Tables with it 
support only the permitted light schema changes, and do not support backup and 
restore. Evaluate these constraints before creating source tables.
+
+## 2. Flink Doris Connector: delivering changes downstream
+
+![Changelog from Doris tables and materialized views becomes a Flink change 
stream that sinks write to Kafka, MySQL, lake tables, or another Doris 
cluster](/images/blogs/apache-doris-5-cdc-changelog/doris-flink-cdc.jpg)
+
+*Figure 5. Internal consumers and Flink can consume the same Changelog for 
different purposes.*
+
+Flink Doris Connector converts Doris changes into Flink insert, update-before, 
update-after, and delete events. Flink sinks can then send them to Kafka, 
MySQL, data lakes, or another Doris cluster.
+
+### 2.1 Declare a Doris table as a change stream
+
+To synchronize order state to a customer-support system, declare the orders 
table in Flink SQL:
+
+```sql
+SET 'execution.checkpointing.interval' = '10s';
+
+CREATE TABLE order_changes (
+    order_id BIGINT,
+    status   STRING,
+    PRIMARY KEY (order_id) NOT ENFORCED
+) WITH (
+    'connector' = 'doris',
+    'fenodes' = '<fe-host>:8030',
+    'table.identifier' = 'shop.orders',
+    'username' = '<doris-user>',
+    'password' = '<doris-password>',
+    'source.scan.mode' = 'initial',
+    'source.changelog.increment-type' = 'min_delta'
+);
+```
+
+The source emits `+I`, `-U`, `+U`, and `-D` records. Connect it to a sink that 
supports the required updates and deletes, such as a primary-key MySQL table or 
upsert-kafka. Two options control how a new consumer starts and reads:
+
+| Option | Values and behavior |
+| --- | --- |
+| `source.scan.mode` | `snapshot` (default): one full read; `initial`: 
snapshot then changes; `latest`: changes from startup; `from-timestamp`: 
changes from `source.scan.timestamp` |
+| `source.changelog.increment-type` | `detail` (default), `min_delta`, or 
`append_only`. With `min_delta`, each poll's read window is the consolidation 
window. |
+
+In `initial` mode, the connector saves the incremental starting position 
before reading the snapshot. Changes committed after that position are covered 
by the snapshot, the incremental stream, or both. This avoids omissions but can 
produce duplicates because the snapshot reads current data while the later 
incremental read also covers changes made during snapshot collection.
+
+The connector therefore provides **at-least-once source delivery**. Downstream 
processing must handle duplicates to achieve exactly-once effects. Duplicate 
Key tables have no primary key to absorb repeated rows; `latest` or 
`from-timestamp`, with a separately managed initial load, is often more 
suitable for them.
+
+See [Incremental Reading with Doris 
Changelog](https://doris.apache.org/docs/dev/connection-integration/data-integration/flink-doris-connector/incremental-read/)
 for connector setup, options, and recovery rules.
+
+### 2.2 Read successive time windows
+
+![An Enumerator plans time windows and assigns Changelog shards to parallel 
Readers using Arrow Flight SQL, with checkpoint state and an optional external 
offset 
table](/images/blogs/apache-doris-5-cdc-changelog/connector-architecture.jpg)
+
+*Figure 6. Checkpoints record read progress. The optional external offset 
table advances after checkpoint completion and records only fully consumed 
windows.*
+
+Two roles cooperate:
+
+- The **Enumerator** obtains the current TSO at each polling interval 
(`source.changelog.poll-interval`, default `10s`), creates a window such as 
`[10:00:00, 10:00:10)`, discovers the Changelog shards, and assigns read tasks.
+- **Readers** read assigned shards in parallel through Arrow Flight SQL and 
convert records into Flink change events.
+
+The next window starts only after every shard in the current window has 
finished. Windows have second-level precision and the minimum poll interval is 
one second. The design targets latency from seconds to tens of seconds; actual 
end-to-end delay also depends on workload, backlog, and downstream processing.
+
+### 2.3 Recover from checkpoints
+
+Checkpoints save the active window and unfinished shards. After failure, the 
job resumes from the latest completed checkpoint. Shards already marked 
complete there stay complete; unfinished shards restart from the beginning of 
that window. Some records can therefore arrive again.
+
+Optionally, `source.changelog.offset-table` and `source.changelog.consumer-id` 
publish progress to a Doris table. This provides a restart position when a job 
is recreated without restoring Flink checkpoint state. The table updates after 
checkpoints complete and records only fully consumed windows, so restarting 
from it can replay a larger range.
+
+Recovery still depends on retention. If the required start has expired, 
`detail` and `append_only` skip expired changes, while `min_delta` fails. 
Configure retention with enough margin and monitor consumption lag.
+
+### 2.4 End-to-end exactly-once effects
+
+A cross-system pipeline cannot share one Doris transaction. The design 
combines **at-least-once delivery from the source with duplicate-safe 
downstream application**.
+
+![At-least-once source delivery and applying repeated events at most once 
combine to provide exactly-once effects, with per-key ordering required for 
upserts](/images/blogs/apache-doris-5-cdc-changelog/exactly-once.jpg)
+
+*Figure 7. “At-most-once” here describes applying a repeated change at most 
once, not a delivery mode that permits data loss.*
+
+On the source side, waiting for transaction visibility closes the requested 
window before reading. Checkpoints and the optional offset table make progress 
recoverable. Replays can occur after checkpoint recovery, during the 
snapshot-to-incremental transition, or when restarting from the external offset 
table. These guarantees assume the needed records remain within retention.
+
+Common downstream strategies include:
+
+- **Primary-key upserts:** A Doris Unique Key table or MySQL table can absorb 
repeated idempotent writes of the same row state.
+- **Further Flink aggregation or joins:** Declare the source primary key and 
set `table.exec.source.cdc-events-duplicate` to `true` so Flink can absorb 
duplicate CDC events. This requires keeping the latest row for each key in 
state.
+- **Append-only destinations:** Ordinary Kafka topics and files need event 
deduplication, for example by `(TSO, LSN, OP)` within the source table. Access 
to these metadata fields requires the DataStream API. An upsert-capable 
destination is another option.
+
+Primary-key upserts also need **per-key order through the sink**. If order 
1001's `paid` update is applied before an older `pending` insert, the final 
state is wrong. Source ordering alone does not establish an end-to-end 
guarantee; downstream partitioning, deduplication, state recovery, and sink 
behavior must preserve the intended effects.
+
+### 2.5 Read shards in parallel
+
+![Changelog shards distributed across Doris nodes are read by several Flink 
Readers in 
parallel](/images/blogs/apache-doris-5-cdc-changelog/parallel-readers.jpg)
+
+*Figure 8. Sharding allows parallel consumption, with no global ordering 
across shards.*
+
+- **Assignment:** The Enumerator hashes shard IDs to Readers. With unchanged 
parallelism, existing assignments remain stable as new shards appear. A small 
number of shards can produce uneven assignments.
+- **Ordering:** Changes for a key stay in one shard and are read sequentially 
by one Reader. Windows are also processed in sequence. Different shards have no 
global output order.
+- **Synchronization:** Every Reader must finish the current window before the 
next begins. The slowest shard sets the pace, especially under skew.
+- **Parallelism limit:** Effective parallelism cannot exceed the number of 
Changelog shards, equal to the sum of bucket counts across partitions. Table 
bucketing therefore limits consumption parallelism.
+
+When a job is rescaled, it restores checkpoint state, replays unfinished 
shards for the window, and assigns work using the new parallelism.
+
+## 3. Process changes inside Doris before delivery
+
+Downstream systems often need changes to derived results rather than raw 
source rows. Doris can prepare those results with two mechanisms:
+
+- [Incremental view maintenance 
(IVM)](https://doris.apache.org/docs/dev/query-acceleration/materialized-view/async-materialized-view/incremental-materialized-view/)
 updates affected parts of a SQL-defined materialized view from base-table 
Changelog, avoiding full recomputation on each refresh.
+- [Table 
Stream](https://doris.apache.org/docs/dev/data-operate/incremental/table-stream/)
 exposes unconsumed table changes and tracks progress. Consuming it with 
`INSERT` commits the result write and progress advance in the same Doris 
transaction. Failure rolls both back.
+
+The result table or materialized view can enable its own Changelog. Its 
derived changes can then be consumed using `DETAIL` or `MIN_DELTA`, creating a 
multi-stage processing pipeline.
+
+### 3.1 Deliver changes to campaign spend
+
+An advertising platform bills per click. Billing entries flow into Doris, 
while a serving system must track cumulative spend per campaign. It pauses a 
campaign when spend reaches its budget. Fraud detection can later insert 
negative reversal entries for invalid clicks, reducing spend and allowing the 
campaign to resume.
+
+The serving system needs a result such as “campaign A's spend changed from CNY 
950 to CNY 1,000.” Sending raw billing events would make it reimplement 
aggregation in Flink or repeatedly query Doris.
+
+#### Use an aggregate materialized view and its Changelog
+
+Define spend per campaign in SQL and incrementally refresh after base-table 
commits. Enable Changelog and before images on the view so every refresh can 
expose changes to cumulative spend.
+
+![An aggregate materialized view turns click billing entries into spend 
changes, pausing a campaign at its budget and resuming it after a 
reversal](/images/blogs/apache-doris-5-cdc-changelog/campaign-spend-ivm.jpg)
+
+*Figure 9. With a CNY 1,000 budget, reaching the limit pauses serving; a 
reversal reducing spend to CNY 970 permits resumption.*
+
+Run the following in Doris. The examples use 16 buckets and the cluster's 
default replication; size both for your deployment.
+
+```sql
+CREATE DATABASE IF NOT EXISTS ads;
+USE ads;
+
+-- Append-only billing entries. Reversals use negative amounts.
+CREATE TABLE click_billing (
+    campaign_id  BIGINT,
+    billing_time DATETIME,
+    amount       DECIMAL(18, 2)
+)
+DUPLICATE KEY (campaign_id, billing_time)
+DISTRIBUTED BY HASH(campaign_id) BUCKETS 16
+PROPERTIES ("changelog.enable" = "true");
+
+-- Incrementally refresh after commits and record changes to the result.
+CREATE MATERIALIZED VIEW campaign_spend_mv
+BUILD IMMEDIATE REFRESH INCREMENTAL ON COMMIT
+KEY (campaign_id)
+DISTRIBUTED BY HASH(campaign_id) BUCKETS 16
+PROPERTIES (
+    "changelog.enable" = "true",
+    "changelog.need_historical_value" = "true"
+)
+AS
+SELECT campaign_id, SUM(amount) AS spend
+FROM click_billing
+GROUP BY campaign_id;
+```
+
+`ON COMMIT` triggers asynchronous refresh tasks. Wait for the initial build to 
succeed before relying on the view; later result changes become available after 
their refresh completes. The following timeline illustrates the resulting spend 
changes rather than guaranteeing a refresh at every wall-clock timestamp.
+
+| Time | Event | Cumulative spend (CNY) | View Changelog |
+| --- | --- | ---: | --- |
+| 10:00:01 | First billing batch | 800 | +I 800 |
+| 10:00:04 | Further charges | 950 | -U 800, +U 950 |
+| 10:00:08 | Charges reach the budget | 1,000 | -U 950, +U 1,000 |
+| 10:00:15 | Reverse CNY 30 of invalid clicks | 970 | -U 1,000, +U 970 |
+
+If the serving system needs only the latest spend, use `MIN_DELTA`. For 
example, the first ten-second window is:
+
+```sql
+SELECT __DORIS_CHANGELOG_OP__ AS op, campaign_id, spend
+FROM campaign_spend_mv@incr(
+    'startTimestamp' = '2026-11-11 10:00:00',
+    'endTimestamp'   = '2026-11-11 10:00:10',
+    'incrementType'  = 'MIN_DELTA'
+);
+```
+
+In the illustrated window, campaign A moves from absent to 800, 950, and 
1,000. Only `+I 1,000` is emitted, prompting a pause. The next window, 
`[10:00:10, 10:00:20)`, emits `-U 1,000` and `+U 970`, prompting resumption. 
Consolidation reduces messages during periods of frequent billing. Use `DETAIL` 
when every recorded transition is needed for reconciliation or spend curves.
+
+#### Use Table Stream when raw and result retention differ
+
+Large billing ledgers may retain only a few days of detail. A materialized 
view, however, represents a query over its retained base data: removing base 
data cannot also preserve an independent lifetime total without changing that 
meaning.
+
+**Table Stream plus a scheduled job separates raw-data retention from 
cumulative results.** The stream reads newly arrived billing entries. A job 
groups each batch by campaign and adds its delta to a result table with 
Changelog enabled.
+
+![An append-only Table Stream and a minute-by-minute job accumulate campaign 
spend independently of three-day raw billing retention, committing results and 
offsets 
atomically](/images/blogs/apache-doris-5-cdc-changelog/campaign-spend-table-stream.jpg)
+
+*Figure 10. Raw entries can expire while the cumulative result remains. 
Retrying a failed stream-consuming write does not add the same batch twice.*
+
+In this alternative, the billing table can use daily partitions with three-day 
retention. The `click_billing` DDL above leaves that production partition 
policy to the deployment. Create the result table, stream, and [scheduled 
job](https://doris.apache.org/docs/dev/admin-manual/workload-management/job-scheduler/)
 in the `ads` database:
+
+```sql
+USE ads;
+
+CREATE TABLE campaign_spend (
+    campaign_id BIGINT,
+    spend       DECIMAL(38, 2)
+)
+UNIQUE KEY (campaign_id)
+DISTRIBUTED BY HASH(campaign_id) BUCKETS 16
+PROPERTIES (
+    "enable_unique_key_merge_on_write" = "true",
+    "changelog.enable" = "true",
+    "changelog.need_historical_value" = "true"
+);
+
+-- Consume only entries arriving after this stream is created.
+CREATE STREAM click_billing_stream ON TABLE click_billing
+PROPERTIES ("type" = "append_only", "show_initial_rows" = "false");
+
+CREATE JOB campaign_spend_job
+ON SCHEDULE EVERY 1 MINUTE
+DO
+INSERT INTO ads.campaign_spend
+SELECT d.campaign_id, COALESCE(s.spend, 0) + d.delta
+FROM (
+    SELECT campaign_id, SUM(amount) AS delta
+    FROM ads.click_billing_stream
+    GROUP BY campaign_id
+) d
+LEFT JOIN ads.campaign_spend s ON s.campaign_id = d.campaign_id;
+```
+
+Each execution commits the result and stream position together. Failure rolls 
both back, so retrying does not double-count the batch. The result table's 
Changelog contains cumulative spend changes. Because `show_initial_rows` is 
`false`, this example starts accumulation only from new arrivals; any 
pre-existing billing data needs a separately coordinated baseline.
+
+Both approaches expose a result Changelog that Flink Doris Connector can 
deliver to the serving system using the pattern in Section 2.1.
+
+### 3.2 Merge out-of-order product streams and suppress irrelevant changes
+
+An e-commerce platform writes products to Doris through two pipelines. 
Real-time CDC captures operational database changes. A daily reconciliation 
pipeline reloads a full snapshot to repair potential gaps. Doris then 
synchronizes prices to a search engine, which needs price changes and product 
deletes.
+
+![A sequence column resolves out-of-order product arrivals, while a price-only 
materialized view and MIN_DELTA remove version-only changes before search 
synchronization](/images/blogs/apache-doris-5-cdc-changelog/product-price-cdc.jpg)
+
+*Figure 11. Keep version information in the base table for correctness, then 
exclude it from the downstream result before computing net changes.*
+
+#### Use a sequence column to handle arrival order
+
+Events from the two pipelines can arrive out of order. The product table maps 
`ver` to a [sequence 
column](https://doris.apache.org/docs/dev/data-operate/update/unique-update-concurrent-control/).
 For the same key, the higher version wins regardless of arrival order; late 
lower-version writes are discarded.
+
+In this scenario, the real-time pipeline derives `ver` from the source 
change's event time, while reconciliation uses the snapshot time. Both 
pipelines must use a comparable version convention.
+
+```sql
+CREATE DATABASE IF NOT EXISTS shop;
+USE shop;
+
+CREATE TABLE product (
+    product_id BIGINT,
+    price      DECIMAL(10, 2),
+    ver        BIGINT
+)
+UNIQUE KEY (product_id)
+DISTRIBUTED BY HASH(product_id) BUCKETS 16
+PROPERTIES (
+    "enable_unique_key_merge_on_write" = "true",
+    "function_column.sequence_col" = "ver",
+    "changelog.enable" = "true",
+    "changelog.need_historical_value" = "true"
+);
+```
+
+Suppose a product originally costs CNY 99 at version 100, drops to CNY 89 at 
version 150, and returns to CNY 99 at version 200. The version-150 event 
arrives last:
+
+| Arrival | Incoming row | Stored result |
+| --- | --- | --- |
+| 1 | CNY 99, ver = 100 | CNY 99, ver = 100 |
+| 2 | CNY 99, ver = 200 | CNY 99, ver = 200 |
+| 3 | CNY 89, ver = 150 | Discarded; CNY 99, ver = 200 remains |
+
+#### Keep version-only writes in the base table
+
+Daily reconciliation rewrites products with a newer `ver` even when prices 
stay unchanged. Forwarding all those updates would cause unnecessary index 
writes.
+
+They cannot simply be discarded at ingestion. Arrival 2 above changes only 
`ver`. If it were discarded because the price stayed at 99, the stored version 
would remain 100. The late version-150 event would then incorrectly replace the 
price with 89.
+
+Reading the base table with `MIN_DELTA` also cannot remove version-only 
changes: it compares the whole row, including `ver`.
+
+#### Project the required columns, then read MIN_DELTA
+
+Create an incremental materialized view containing only product ID and price, 
with its own Changelog and before images. When only `ver` changes, the view's 
before and after rows are identical, so `MIN_DELTA` suppresses the update.
+
+```sql
+CREATE MATERIALIZED VIEW product_price_mv
+BUILD IMMEDIATE REFRESH INCREMENTAL ON COMMIT
+KEY (product_id)
+DISTRIBUTED BY HASH(product_id) BUCKETS 16
+PROPERTIES (
+    "changelog.enable" = "true",
+    "changelog.need_historical_value" = "true"
+)
+AS
+SELECT product_id, price FROM product;
+
+-- Illustrative ten-second window after the relevant refreshes complete.
+SELECT __DORIS_CHANGELOG_OP__ AS op, product_id, price
+FROM product_price_mv@incr(
+    'startTimestamp' = '2026-11-11 10:00:00',
+    'endTimestamp'   = '2026-11-11 10:00:10',
+    'incrementType'  = 'MIN_DELTA'
+);
+```
+
+Assuming the product already exists at the start, each window has the 
following effects:
+
+| Changes within the window | MIN_DELTA output | Search engine action |
+| --- | --- | --- |
+| Reconciliation changes only `ver` | None | None |
+| Price falls from CNY 99 to CNY 89 | -U 99, +U 89 | Set price to CNY 89 |
+| Price falls to CNY 89 and returns to CNY 99 | None | None |
+| Product is deleted at price CNY 99 | -D 99 | Remove the product |
+
+Flink Doris Connector can read the view's Changelog and deliver these 
meaningful result changes downstream.
+
+## What comes next
+
+Changelog extends Doris's role in a real-time pipeline: Doris can ingest data, 
compute results, and continuously expose changes to those results. IVM and 
Table Stream prepare changes inside the database; Flink Doris Connector carries 
them to other systems.
+
+The next article will examine IVM internals and incremental execution plan 
generation. Changelog is planned for Apache Doris 5.0; consult the 
documentation and release announcements for availability.
diff --git a/blog/apache-doris-5-multimodal-lakehouse-preview.md 
b/blog/apache-doris-5-multimodal-lakehouse-preview.md
index b627fa1b4b9..85b6ffabf1d 100644
--- a/blog/apache-doris-5-multimodal-lakehouse-preview.md
+++ b/blog/apache-doris-5-multimodal-lakehouse-preview.md
@@ -2,8 +2,6 @@
 title: 'Apache Doris 5.0 Preview(1): A Unified Multimodal Lakehouse for 
Real-Time Analytics'
 summary: 'A look at how Doris plans to extend unified search and real-time 
analytics across open lake formats and multimodal data.'
 description: 'Explore the Apache Doris 5.0 multimodal lakehouse preview, 
including open-format integration, Variant and vector analytics, Physical AI, 
and agent use cases.'
-picked: "true"
-order: "1"
 keywords:
   - 'Apache Doris 5.0'
   - 'multimodal lakehouse'
diff --git a/blog/apache-doris-lance-physical-ai-analytics.md 
b/blog/apache-doris-lance-physical-ai-analytics.md
index c26ccecd8af..cf65bf79611 100644
--- a/blog/apache-doris-lance-physical-ai-analytics.md
+++ b/blog/apache-doris-lance-physical-ai-analytics.md
@@ -2,8 +2,6 @@
 title: 'Apache Doris x Lance for Autonomous Driving and Robotics Analytics'
 summary: 'Doris and Lance combine episode search, structured filters, and OLAP 
analysis to help teams find hard cases and diagnose failures in Physical AI 
data.'
 description: 'How Apache Doris and Lance support hard-case mining for 
autonomous driving and failure analysis for robotics with open multimodal 
datasets.'
-picked: "true"
-order: "2"
 keywords:
   - 'Apache Doris'
   - 'Lance Catalog'
diff --git a/blog/hubspot-apache-doris-search-analytics.mdx 
b/blog/hubspot-apache-doris-search-analytics.mdx
new file mode 100644
index 00000000000..1a989195fea
--- /dev/null
+++ b/blog/hubspot-apache-doris-search-analytics.mdx
@@ -0,0 +1,273 @@
+---
+title: 'One Engine for Search and Analytical Queries: How HubSpot Runs Apache 
Doris Across 33 Clusters'
+summary: 'HubSpot runs CRM object analytics on 33 Apache Doris clusters 
worldwide. Learn how VARIANT, controlled query fan-out, and priority-based 
ingestion cut P50 backend latency from about 1.8 seconds to 500 milliseconds.'
+description: 'How HubSpot uses Apache Doris for CRM object analytics across 33 
clusters, with typed VARIANT columns, inverted indexes, controlled query 
fan-out, cell-based deployment, and prioritized ingestion.'
+picked: "true"
+order: "1"
+keywords:
+  - 'Apache Doris'
+  - 'HubSpot'
+  - 'CRM analytics'
+  - 'VARIANT'
+  - 'full-text search'
+  - 'Group Commit'
+  - 'Doris Summit 2026'
+date: '2026-11-20'
+author: 'HubSpot · Alvaro Tuso'
+tags:
+  - 'Best Practice'
+image: '/images/blogs/hubspot-apache-doris-search-analytics/cover.jpg'
+---
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+<YouTube
+  videoId="aP76bXhZ32Q"
+  title="How HubSpot Runs Apache Doris Across 33 Clusters"
+  poster="/images/blogs/hubspot-apache-doris-search-analytics/video-poster.jpg"
+/>
+
+*Queries on HubSpot's CRM data have to filter on any property and match text 
like a search engine, then join across many-to-many associations and aggregate 
like an analytical database. HubSpot needed one engine for both search and 
analytical queries, and chose Apache Doris, a real-time analytical and search 
database. Analytical queries on CRM objects now run on 33 Doris clusters 
worldwide, and P50 backend latency has dropped from about 1.8 seconds to about 
500 milliseconds.*
+
+:::tip
+
+This article is based on Evolving Semi-Structured Search & Analytical Queries 
at HubSpot, an Apache Doris Summit 2026 talk by HubSpot Staff Software Engineer 
Alvaro Tuso. A big thank-you to Alvaro for generously sharing his experience 
and insights with the Apache Doris community! The full recording is available 
on demand.
+
+:::
+
+Imagine a HubSpot user who wants to know which industries employ the contacts 
whose text property contains the word "acme", how many of those contacts each 
industry has, and what one of their numeric properties adds up to. The question 
needs both search and analytics: it matches text on contacts, joins them to 
companies through an association table, and then groups and aggregates by 
industry. Writing it in SQL is straightforward. The hard part is the data 
itself. Customers define most of [...]
+
+HubSpot moved this workload to Apache Doris. **After analytical queries on CRM 
objects switched to Doris, P50 backend latency dropped from about 1.8 seconds 
to about 500 milliseconds, and the end-to-end time users experience fell from 
about 2 seconds to about 1 second.** These queries now run on 33 Doris clusters 
worldwide. Search, built on the same data model, is under way.
+
+This article covers what makes HubSpot's data hard, why HubSpot chose Doris, 
the designs it built on top of Doris, and how it scaled from one cluster to a 
global deployment. It closes with the next steps for search and events.
+
+<YouTube
+  videoId="knADAP8z_Wc"
+  title="Evolving Semi-Structured Search & Analytical Queries at HubSpot"
+  
poster="/images/blogs/hubspot-apache-doris-search-analytics/talk-video-poster.jpg"
+/>
+
+## The Problem: Every Customer Has Its Own Schema
+
+HubSpot's CRM can be viewed as a schema that each tenant defines for itself 
(Figure 1). Internally, HubSpot calls a tenant a portal. Objects are the main 
entities. An object type works like a table, such as contacts, companies, or 
deals, and customers can create their own object types. Properties work like 
columns: each has a type, and customers can define their own. Associations are 
many-to-many relationship tables between objects. They link a contact to the 
company where the contact wo [...]
+
+![HubSpot's CRM data model: one portal, which is one customer with its own 
schema, holds object-type tables such as Contacts, Companies, and a custom 
object, whose columns are properties. Lines marked M:N link rows across tables, 
a List tags a subset of contacts, and a dense stream of time-stamped events 
runs along the 
bottom.](/images/blogs/hubspot-apache-doris-search-analytics/crm-data-model.jpg)
+
+*Figure 1: How HubSpot's CRM data is organized.*
+
+The scale is substantial. Object data is less than 1 PB, and event data is 
larger still. Ingestion runs at about 120,000 requests per second, and about 
90% of those requests update existing records. Search runs at about 20,000 QPS. 
The traffic comes from users querying in the product UI, agents calling the 
API, HubSpot's AI assistant Breeze, and other HubSpot systems that need to look 
up objects.
+
+Two kinds of queries run on this data. Search filters on arbitrary properties 
and adds text matching, sorting, and limits. Each search query is simple, but 
QPS is high and latency targets are strict. Analytical queries run at much 
lower QPS and filter in a similar way, but they also join up to five object 
types and then aggregate. Every additional object type adds another hop through 
a many-to-many relationship table, so real queries often contain around 10 
joins and are expensive in bot [...]
+
+![Four icons labeled Schema (arbitrary and different for each tenant), Joins 
(up to 5 hops through a relationship table), Ingestion (massive update volume), 
and Search (text search, with scoring and semantic search 
later).](/images/blogs/hubspot-apache-doris-search-analytics/crm-query-challenges.jpg)
+
+*Figure 2: The four challenges HubSpot faced.*
+
+The challenges come down to four (Figure 2):
+
+1. The schema differs by tenant. Some customers have thousands of properties 
on a single object type. A system with a fixed schema can materialize only some 
of them and has to put the rest into a JSON map.
+2. Joins. Analytical databases handle joins well, and search engines usually 
do not. Few systems do both.
+3. Ingestion is dominated by updates. The faster data is written, the more 
files a query has to read and the harder it becomes to keep query latency low, 
so data freshness and query latency pull against each other.
+4. Search. HubSpot needs text search today, and scoring and semantic search 
later.
+
+**HubSpot was looking for a database that could put search and analytical 
queries in the same engine.**
+
+## Why Apache Doris
+
+That is exactly how Apache Doris is positioned: as a real-time analytical and 
search database. Alongside the joins and aggregations of an analytical 
database, Doris has built-in [inverted indexes and full-text 
search](https://doris.apache.org/docs/dev/table-design/index/inverted-index/overview/).
 During its evaluation, HubSpot contacted VeloDB and ran a set of analytical 
and search queries on a small sample of its data in VeloDB Cloud, VeloDB's 
managed service. The results were strong. T [...]
+
+![A honeycomb of four Doris capabilities: Variant (typed, materialized 
sub-paths with inverted indexes), Merge-on-Write (a massive update cadence with 
lower query-time overhead), decoupled mode (compute-storage separation), and 
Fast (strong ingestion and query 
performance).](/images/blogs/hubspot-apache-doris-search-analytics/doris-capabilities.jpg)
+
+*Figure 3: The four Doris capabilities behind the choice.*
+
+Four Doris capabilities drove the decision (Figure 3):
+
+- 
[VARIANT](https://doris.apache.org/docs/dev/sql-manual/basic-element/sql-data-types/semi-structured/VARIANT/):
 This was the most important capability. VARIANT can match column names by 
pattern, assign types to the matched sub-paths, and materialize those sub-paths 
in the backend as regular columns, which can also carry inverted indexes. **As 
a result, HubSpot can model every customer-defined object type and property as 
a real column, without having to choose between materializing only  [...]
+- [Unique Key 
model](https://doris.apache.org/docs/dev/table-design/data-model/unique/): 
HubSpot's objects, associations, and events all have idempotent IDs, which map 
naturally onto the Unique Key model. When a write commits, Doris marks the old 
row as deleted and skips it at query time, which removes most of the merge work 
at read time.
+- [Compute-storage 
decoupling](https://doris.apache.org/docs/dev/features-architecture/system-architecture/):
 HubSpot's customers vary widely in size. Decoupling compute from storage makes 
it easier to isolate customers from one another and to limit the impact of any 
failure.
+- Performance: Ingestion and query latency both stay low, even while data is 
written continuously.
+
+These capabilities made the approach possible. The final results depended on 
the designs HubSpot built on top of Doris.
+
+## A Deep Dive into Doris at HubSpot
+
+Each of the four designs below builds on a Doris capability and adds a layer 
of HubSpot's own engineering.
+
+### Turning Arbitrary Properties into Typed Columns
+
+Customers' raw property names cannot serve directly as column names. Contacts 
have a first name, companies may only have a name, and every custom object 
names things its own way. Across all customers, there are millions of distinct 
property names or more, and no database can materialize all of them.
+
+HubSpot reused an approach it originally designed for Elasticsearch: it groups 
properties by type and numbers them within each object type. A contact's first 
name might map to `string_1`, and a company's name can also be `string_1`. This 
sharply reduces the number of distinct sub-path names in the VARIANT column, to 
a few hundred in one table and a few thousand in the other. HubSpot also split 
the object table in two by column count, one table with few columns and one 
with many, so that  [...]
+
+On top of these slots, HubSpot uses VARIANT type patterns (`MATCH_NAME_GLOB`) 
to assign a type by prefix. The patterns cover Booleans, datetimes, enums, 
numbers, number arrays, text, and phone numbers. Phone numbers get their own 
prefix because they are searched differently from regular text. HubSpot sets 
`variant_max_subcolumns_count` to 50,000. This deliberately high limit is never 
reached in practice; its purpose is to ensure that every sub-path is 
materialized as a column (Figure 4).
+
+![Customer property names such as Contact · First name and Company · Name map 
to typed slots such as string_1, number_12, and phone_1. MATCH_NAME_GLOB turns 
each slot into a typed sub-column of the VARIANT column named properties, and 
some sub-columns carry inverted 
indexes.](/images/blogs/hubspot-apache-doris-search-analytics/variant-typed-columns.jpg)
+
+*Figure 4: From customer property names to typed sub-columns in VARIANT.*
+
+HubSpot also defines inverted indexes by field pattern (`field_pattern`). 
Normalized strings, phone numbers, and number arrays each get their own kind of 
index, paired with HubSpot's custom analyzers, such as `standard_normalized` 
and `normalized_edge_ngram_phone_number` below. The approach resembles dynamic 
templates in Elasticsearch. Some HubSpot products use Elasticsearch, so HubSpot 
worked with VeloDB to make text matching in Doris behave the same way as in 
those products.
+
+```sql
+-- VARIANT column in the object table
+`properties` variant<
+  MATCH_NAME_GLOB 'boolean_*':boolean,
+  MATCH_NAME_GLOB 'datetime_*':bigint,
+  MATCH_NAME_GLOB 'enum_*_raw':array<text>,
+  MATCH_NAME_GLOB 'number_*':decimal(38,10),
+  MATCH_NAME_GLOB 'numberArray_*':array<decimal(38,10)>,
+  MATCH_NAME_GLOB 'string_*_raw':text,
+  MATCH_NAME_GLOB 'phone_*':text,
+  PROPERTIES(
+    'variant_max_subcolumns_count' = '50000',
+    'variant_enable_typed_paths_to_sparse' = 'false'
+  )
+>
+
+-- Inverted indexes defined by field pattern
+INDEX idx_string_norm_standard (`properties`) USING INVERTED PROPERTIES(
+  "support_phrase" = "true",
+  "field_pattern" = "string_*_norm",
+  "analyzer" = "standard_normalized"
+),
+INDEX idx_phone_ngram (`properties`) USING INVERTED PROPERTIES(
+  "support_phrase" = "true",
+  "field_pattern" = "phone_*",
+  "analyzer" = "normalized_edge_ngram_phone_number"
+),
+INDEX idx_numberArray (`properties`) USING INVERTED PROPERTIES(
+  "field_pattern" = "numberArray_*"
+)
+```
+
+To learn how VARIANT works internally, see the [VARIANT deep 
dive](https://doris.apache.org/blog/variant-tech-deepdive-202601/) on the 
Apache Doris website.
+
+**Lesson: normalize property names into a bounded set of typed slots in the 
application layer, then let VARIANT materialize them.**
+
+### Controlling Query Fan-Out
+
+The object table defines its key and data distribution as follows. `portalId` 
is the tenant ID, `objectTypeId` identifies the object type (that is, a table 
in the CRM), and `objectId` is the ID of the object itself.
+
+```sql
+UNIQUE KEY(`portalId`, `objectTypeId`, `objectIdHash`, `objectId`)
+DISTRIBUTED BY HASH(`portalId`, `objectTypeId`, `objectIdHash`) BUCKETS 256
+```
+
+The important part is the extra `objectIdHash` column. Within a single 
customer, object types can differ enormously in size: a customer might have a 
million contacts but only ten companies. If Doris distributed data only by 
tenant and object type, all one million contacts would land in a single tablet 
(a Doris data shard) on a single BE (backend node). If Doris spread the data 
across every BE instead, even a query for ten rows would have to touch every BE.
+
+`objectIdHash` is a hash computed from the object ID. Because it appears in 
both the key and the distribution key, HubSpot can control from the application 
side how many tablets each object type is split into. HubSpot knows each 
customer's write rate and the data volume of each object type, and decides the 
split accordingly: a single tablet for a small object type, for example, and 
ten for a medium one. This takes a fair amount of application-side work. At 
query time, the application pas [...]
+
+![Three panels, each with six BEs. Hashing by portal and object type puts one 
million contacts on one BE. Spreading data across all BEs makes a 10-row query 
touch every BE. Adding objectIdHash lets the query reach only the BE that holds 
the 
rows.](/images/blogs/hubspot-apache-doris-search-analytics/query-fan-out.jpg)
+
+*Figure 5: Tablet placement and query fan-out under three distribution 
schemes.*
+
+Putting these designs together gives the example analytical query below, which 
answers the question at the beginning of this article. It filters contacts on a 
text property, joins them to companies through the association table, groups by 
company industry, and then counts contacts and sums a numeric property. The 
query first casts VARIANT sub-paths to concrete types, because the FE (frontend 
node) does not know the type of a sub-path; once the type is declared, the 
query can use the inde [...]
+
+```sql
+SELECT
+  CAST(co.properties['string_4_raw'] AS TEXT) AS industry,
+  COUNT(DISTINCT c.objectid) AS contacts,
+  SUM(CAST(c.properties['number_12'] AS DECIMAL(38, 10))) AS total_value
+FROM objects c
+JOIN associations a
+  ON a.portalid = c.portalid
+  AND a.fromobjectid = c.objectid
+JOIN objects co
+  ON co.portalid = a.portalid
+  AND co.objectid = a.toobjectid
+WHERE c.portalid = 1
+  AND c.objecttypeid = '0-1'
+  AND c.objectidhash IN (0)
+  AND CAST(c.properties['string_8_norm'] AS TEXT) MATCH_PHRASE 'acme'
+GROUP BY industry
+ORDER BY contacts DESC
+LIMIT 100;
+```
+
+**Lesson: use a power of two for the bucket count.** HubSpot studied and 
tested the hash function that Doris uses and found that powers of two produce 
fewer collisions and spread data more evenly across buckets.
+
+### Many Small Clusters Instead of One Big One
+
+HubSpot runs as many services as possible on Kubernetes, with a single 
Kubernetes cluster per data center, and Doris is no exception. Doris runs in 
Kubernetes on AWS EC2, in compute-storage decoupled mode with FoundationDB, 
entirely on ARM64 Graviton instances. HubSpot also tried mixing in AMD 
instances and found that Doris performs much better on ARM64.
+
+The pods use the Kubernetes Burstable QoS class. CPU requests match the steady 
load of ingestion and queries, while CPU limits leave generous headroom. As a 
result, pods from several Doris clusters can share a node, and a query can 
briefly use extra CPU when it needs to. These bursts are infrequent and barely 
visible in node metrics, yet they noticeably cut tail latency, which helps 
analytical queries in particular. To make this work, HubSpot tuned Doris and 
proposed a change to how cgro [...]
+
+The bigger question was how to divide the clusters. From the start, HubSpot 
did not aim for one giant cluster per data center that held every customer's 
data. Growing a small experiment straight to that scale would have wasted 
significant resources and caused repeated rework. The cell-based architecture 
that HubSpot is adopting also calls for small clusters with a small blast 
radius.
+
+![Customers of different sizes are scored by load, split into groups of about 
5%, and routed by the application to identical small clusters, with HubSpot's 
own portal in a separate cluster. Along the bottom are the benefits: a simpler 
schema, small tablets, and a small blast 
radius.](/images/blogs/hubspot-apache-doris-search-analytics/cell-architecture.jpg)
+
+*Figure 6: Customers grouped by load, with one identically configured small 
cluster per group.*
+
+In practice, HubSpot computes a composite load score for each customer from 
data volume, write volume, search volume, analytical query volume, and latency. 
It then splits all customers into groups that each account for about 5% of the 
total load. Each group gets its own identically configured small cluster, and 
the application layer handles routing. HubSpot's own account carries a 
particularly heavy load, so it runs in a separate cluster. As Figure 6 shows, 
small clusters bring three ben [...]
+
+HubSpot has strict security requirements for its data stores. Doris provides 
audit logging by default. To trace which system each query comes from, HubSpot 
created a separate database user for each infrastructure component. HubSpot 
also worked with VeloDB to implement mTLS for all traffic within a cluster in 
VeloDB Enterprise, along with database user authentication based on certificate 
SANs (Subject Alternative Names): only a system that holds the matching 
certificate can connect as that user.
+
+**Lesson: when every cluster is configured the same way, results on a 5% 
sample predict the full rollout.** After analytical queries went live on the 
first cluster, HubSpot was confident that it could scale to 100% quickly. Its 
method for measuring customer load was reliable, and the results were 
consistently reproducible. The rollout described in the next section bore this 
out.
+
+### Fresh Data Without Slower Queries
+
+Most of the work during the scale-up went into ingestion.
+
+![CRM updates are prioritized and debounced into Kafka lanes for user edits, 
automations, and backfill. Java workers send user edits through synchronous 
Stream Load and everything else through Group Commit, throttle backfill based 
on compaction score and CPU, and publish transaction labels to track when data 
becomes 
visible.](/images/blogs/hubspot-apache-doris-search-analytics/priority-ingestion.jpg)
+
+*Figure 7: The ingestion pipeline, with lanes separated by priority.*
+
+HubSpot first prioritizes ingestion traffic by its source (Figure 7). A user 
who edits a record by hand expects to see the change immediately, while an 
automation can usually take effect a few minutes later. High-priority writes 
target visibility within 5 seconds; lower priorities can take a few minutes.
+
+Upstream CRM updates go through prioritization and debouncing, then into Kafka 
topics partitioned by cluster × table × priority. Each topic acts as a lane. 
HubSpot's own Java workers consume the lanes and write to the corresponding 
cluster through [Stream 
Load](https://doris.apache.org/docs/dev/data-operate/import/import-way/stream-load-manual/).
 The highest priority uses synchronous Stream Load and commits immediately. All 
other traffic uses [Group Commit](https://doris.apache.org/docs/ [...]
+
+Together with the Unique Key model described earlier, this design keeps 
frequent updates from turning into merge costs at query time.
+
+**Lesson: reserve synchronous Stream Load for the writes users are waiting on, 
and let Group Commit batch everything else.**
+
+## Rollout and Results
+
+With customers grouped into identically configured small clusters, HubSpot 
rolled out analytical queries in four steps (Figure 8). It started with one 
cluster in the NA1 data center, serving a sample of about 5% of customers. It 
then expanded to three clusters and about 15% of customers, then to all 21 
clusters in NA1, and finally to the global deployment of 33 clusters.
+
+![Four steps: 5% Sample Testing (1 cluster in the NA1 data center), 15% Sample 
Testing (3 clusters in NA1), 100% NA1 (21 clusters), and Global (33 clusters in 
total).](/images/blogs/hubspot-apache-doris-search-analytics/global-rollout.jpg)
+
+*Figure 8: Analytical queries scaled from a 5% sample to 33 clusters 
worldwide.*
+
+**Going from the validated three-cluster stage to the global deployment took 
only about three weeks.** Two things made the rollout smooth: the way HubSpot 
grouped customers into clusters, and Doris itself.
+
+Figure 9 shows about two hours of monitoring around the switch. The yellow 
line is the backend execution time of analytical queries. It drops sharply at 
the switch to Doris and keeps falling over the following hour or so, **with P50 
going from about 1.8 seconds to about 500 milliseconds**. The green line is the 
end-to-end time that users experience, which falls from about 2 seconds to 
about 1 second. The lower latency has also led to higher customer satisfaction.
+
+![Monitoring chart from about 14:30 to 16:25. Backend latency (yellow) drops 
sharply from about 1.8 seconds around 15:24 and settles near 0.5 seconds, while 
end-to-end latency perceived by users (green) falls from about 2 seconds to 
about 1 
second.](/images/blogs/hubspot-apache-doris-search-analytics/p50-query-latency.jpg)
+
+*Figure 9: P50 query latency over about two hours around the switch. Yellow is 
backend latency; green is the end-to-end time that users experience.*
+
+## What's Next: Search and Events
+
+HubSpot's next step is to run search on Doris as well. Search and analytical 
queries share the same data model. Through the partnership, HubSpot and VeloDB 
have already made several improvements for search: a query function used much 
like the Elasticsearch query string, inverted index predicate pushdown in 
certain joins, better concurrency, and smooth rolling restarts. The two teams 
have also delivered fixes for cgroup memory accounting, concurrent cumulative 
compaction, and other areas, [...]
+
+The main challenges now are high concurrency and cache availability. The cache 
holds only one copy of the data, so losing a single node noticeably hurts 
workloads with strict latency requirements. Newer Doris releases already 
address this with [Peer 
Read](https://doris.apache.org/docs/dev/compute-storage-decoupled/file-cache/file-cache-peer-read/).
 High QPS is a challenge for most databases, but the results so far are very 
good. Next, HubSpot plans to upgrade to a newer release and start [...]
+
+Events are another direction. Today, only object queries run on Doris, and 
HubSpot wants to run analytical queries on events next. Event data is orders of 
magnitude larger than object data and already lives entirely in Iceberg, so 
HubSpot plans to start by querying Iceberg directly through Doris. Because 
event data does not fit in the cache, object data will need to be pinned in the 
cache. If performance falls short, HubSpot will consider a hybrid architecture.
+
+Further out, HubSpot plans to consolidate more datasets into Doris and 
evaluate capabilities such as federated queries, which would give other teams 
more flexible options.
+
+---
+
+This article is based on [*Evolving Semi-Structured Search & Analytical 
Queries at HubSpot*](https://apache-doris-summit.org/watch/hubspot), a Doris 
Summit 2026 talk by HubSpot Staff Software Engineer Alvaro Tuso. The full 
recording is available on demand. Figures 2, 3, 8, and 9 come from the talk's 
slides; the other figures were created for this article based on the talk. This 
article is part of the Doris Summit 2026 series. The [Doris Summit 2026 
Recap](/blog/doris-summit-2026-recap) c [...]
+
+Get involved with the community:
+
+- Website: [https://doris.apache.org](https://doris.apache.org)
+- Contribute: 
[https://doris.apache.org/community/how-to-contribute/contribute-to-doris](https://doris.apache.org/community/how-to-contribute/contribute-to-doris)
+- GitHub: [github.com/apache/doris](https://github.com/apache/doris)
+- Slack: [doris.apache.org/slack](https://doris.apache.org/slack)
diff --git a/blog/jd-apache-doris-lakehouse-query-optimization.md 
b/blog/jd-apache-doris-lakehouse-query-optimization.md
new file mode 100644
index 00000000000..8cd8c5f0b5b
--- /dev/null
+++ b/blog/jd-apache-doris-lakehouse-query-optimization.md
@@ -0,0 +1,169 @@
+---
+title: 'How JD.com Uses Apache Doris for Millions of Daily Lakehouse Queries 
and PB-Scale Scans'
+summary: 'JD.com is consolidating Presto and StarRocks workloads on Apache 
Doris. Explore its optimizations for split scheduling, partition pruning, file 
listing, and execution across BI, data quality, and AI agent queries.'
+description: 'How JD.com builds a unified Apache Doris lakehouse query engine 
for millions of daily queries and petabyte-scale scans, with push-based 
scheduling, partition pruning, and vectorized execution.'
+picked: "true"
+order: "2"
+keywords:
+  - 'Apache Doris'
+  - 'JD.com'
+  - 'lakehouse query optimization'
+  - 'partition pruning'
+  - 'split scheduling'
+  - 'Nereids optimizer'
+date: '2026-11-10'
+author: 'JD.com · Conghui Cai'
+tags:
+  - 'Best Practice'
+image: '/images/blogs/jd-apache-doris-lakehouse-query-optimization/cover.jpg'
+---
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+:::tip
+
+Adapted from Conghui Cai's presentation at Doris Summit 2026. Cai is the OLAP 
Engine Tech Lead at JD Retail and an Apache Doris PMC member. The [original 
article](https://selectdb.com/blog/jd-apache-doris-lakehouse-query-optimization)
 was published on November 10, 2026. The optimizations below describe JD.com's 
production implementation.
+
+:::
+
+Growing business analytics demand and new AI agent queries have made JD.com's 
lakehouse workloads more varied. Running several query engines in parallel 
added architectural complexity, made resource scheduling harder, and 
complicated unified governance.
+
+JD.com is gradually moving workloads from Presto, StarRocks, and other 
analytical engines to Apache Doris. Using Doris's Multi-Catalog capabilities, 
Nereids optimizer, and vectorized execution engine, the team has optimized the 
path from query scheduling and partition pruning to file scanning and execution 
resource management.
+
+The unified engine now handles **millions of queries and petabyte-scale data 
scans each day**. AI agent queries account for approximately **20% of 
queries**, alongside BI reports and data quality tasks.
+
+This article explains how JD.com's architecture evolved and how the team 
adapted Doris to large-scale lakehouse queries and mixed workloads.
+
+## 1. From multiple engines to a unified lakehouse
+
+JD.com adopted Apache Doris early in its open source history to support 
advertising reports, while Presto remained its main lakehouse query engine. The 
team later introduced StarRocks and other analytical engines. During 2024 and 
2025, it began consolidating OLAP workloads by migrating Presto and StarRocks 
workloads to Doris. In 2026, it continued building a unified architecture 
around Doris to reduce complexity and support a broader range of analytical 
needs over time.
+
+![JD.com's lakehouse query architecture evolves from Presto in 2021 and 
StarRocks exploration in 2022 to migration during 2024–2025 and a unified Doris 
architecture in 
2026](/images/blogs/jd-apache-doris-lakehouse-query-optimization/architecture-evolution.png)
+
+Historically, lakehouse queries followed a daily pattern with two peaks. 
Morning traffic mainly came from business analysis and BI reports. Overnight, 
large numbers of data quality tasks ran complex SQL queries.
+
+As AI agent queries grew to about 20% of the total, that pattern began 
changing into a **continuous, 24/7 mixed workload**. Interactive queries, batch 
scans, and agent requests have different latency, throughput, and isolation 
requirements. JD.com needed an engine that could access existing lake data 
efficiently while supporting complex planning and execution.
+
+## 2. Building the unified query architecture
+
+### Why Apache Doris
+
+Three capabilities provided the foundation for JD.com's choice.
+
+**Multi-Catalog access to lake data.** Doris can query Hive, Iceberg, Hudi, 
Paimon, and other external sources through one engine. This lets JD.com 
consolidate compute while keeping its existing lakehouse storage, reducing 
migration and architectural changes. See the [Catalog 
overview](https://doris.apache.org/docs/dev/lakehouse/catalog-overview/) for 
how Doris connects to external systems.
+
+**Query optimization.** Lakehouse SQL performance depends on partition 
pruning, statistics, join planning, and scan task generation as well as scan 
speed. Doris's [Nereids 
optimizer](https://doris.apache.org/docs/dev/query-acceleration/optimization-technology-principle/query-optimizer/)
 provides rule-based, cost-based, and history-based optimization capabilities 
and a framework for JD.com's workload-specific improvements.
+
+**Vectorized and distributed execution.** Doris's backend execution engine 
supports scanning, filtering, aggregation, and distributed computation across 
several file formats. This provides a common execution foundation for BI, data 
quality, and agent workloads.
+
+### Four layers of the architecture
+
+JD.com's unified lakehouse architecture has four main layers:
+
+- **Business access:** BI reports, business analysis, data quality tasks, and 
AI agents submit concurrent interactive queries and large batch scans.
+- **Unified query entry point:** SQL dialect compatibility, authentication, 
and access governance prepare requests for Doris. Compatibility conversion 
accommodates existing Presto SQL and Spark SQL within the supported scope.
+- **Doris compute engine:** Frontends (FEs) handle query planning, metadata 
access, partition pruning, and task coordination. Backends (BEs) scan files, 
evaluate expressions, aggregate results, and exchange data.
+- **Lakehouse storage:** JD.com retains its existing data organization and 
storage systems, including Hive, Hudi, ORC, and Parquet, with adapters for 
internal storage systems.
+
+Together, these layers support millions of daily queries, PB-scale daily 
scans, and increasingly continuous mixed workloads.
+
+## 3. Optimizing the path from planning to execution
+
+At this scale, computation is only part of query latency. Metadata retrieval, 
partition pruning, file listing, scan task scheduling, and resource management 
can all become bottlenecks. JD.com's work addresses the preparation and 
execution of queries together.
+
+### Push-based scheduling reduces scanner wait time
+
+For large lakehouse scans, the FE continually creates and distributes scan 
splits. In the Doris implementation JD.com previously used, BEs pulled batches 
of tasks on demand. When a local batch ran out, scanner threads could block 
while waiting for the FE. Metadata latency fluctuations could therefore occupy 
scan resources without doing useful work.
+
+The team changed the scheduling protocol between the FE Coordinator and BE 
Scanner to a **push model**. The FE asynchronously pushes splits, while the BE 
maintains a bounded queue. When no local task is ready, the scanner suspends 
and releases CPU resources. New tasks wake it again. Capacity and consumption 
feedback regulate the supply of work.
+
+![Pull scheduling blocks a scanner while fetching another batch; push 
scheduling supplies splits asynchronously and uses queue capacity and 
consumption 
feedback](/images/blogs/jd-apache-doris-lakehouse-query-optimization/split-scheduling.png)
+
+The change has three main benefits:
+
+1. **Release scanner resources while waiting.** Suspending scanners reduces 
the resources occupied by metadata waits, especially during concurrent file 
listing or metadata latency fluctuations.
+2. **Limit task accumulation.** When queues lack capacity, backpressure pauses 
producers and limits split buffering during scans over many files and 
partitions.
+3. **Account for different consumption rates.** Scheduling considers BE queue 
and execution state, avoids full queues, and reduces imbalance and slow tails 
caused by different BE processing rates.
+
+![Comparison of pull and push scheduling across waiting behavior, buffer 
control, assignment feedback, and task 
replenishment](/images/blogs/jd-apache-doris-lakehouse-query-optimization/pull-push-comparison.png)
+
+The practical lesson is to **reduce the compute resources consumed by task 
preparation and waiting**, alongside improving execution speed.
+
+### Earlier partition pruning avoids unnecessary metadata requests
+
+Large Hive tables can contain many partitions. With a cold cache, fetching 
metadata for all of them can make planning expensive before execution even 
begins.
+
+Using the Nereids framework, JD.com moved query predicates earlier into 
candidate partition retrieval. The goal is to **fetch partitions on demand and 
exclude irrelevant data as early as possible**. The team extended predicate 
inference in several ways:
+
+- Rewrite conditions involving functions such as `date_trunc` into ranges on 
partition columns when the rewrite preserves semantics.
+- For very long `IN` lists, use a range to prefilter candidate partitions, 
then retain the original predicate in the FE for exact filtering.
+- Use constant folding and other simplifications early in planning to keep 
unnecessary partitions out of later stages.
+
+![File-level splitting and predicate-aware partition retrieval reduce 
unnecessary scan splits and metadata 
work](/images/blogs/jd-apache-doris-lakehouse-query-optimization/partition-pruning.png)
+
+The presentation also illustrates Hive bucket pruning, partition-extrema 
scans, and filtering zero-byte files before split generation. Bucket pruning 
applies to eligible non-ACID Hive tables when the bucket key values can be 
computed; it still requires file listing and retains the original row 
predicate. The partition-extrema optimization described here is limited to 
`MIN/MAX` on the same partition column without `GROUP BY`, with filters covered 
by partition columns, on the supported Hiv [...]
+
+JD.com also addressed duplicated preparation work between file listing and 
cost-based optimizer statistics collection. **List files once, then reuse the 
result** for both cost estimation and scan split generation. Within a query, 
accesses to the same table and partition range can share the enumeration result.
+
+For data volume estimates, the engine first uses valid statistics for the 
selected partitions. If those statistics are missing, it estimates from total 
file size, a decompression factor, and row width. This reduces dependence on 
fetching per-column statistics from the metastore while preserving useful 
planning information.
+
+![A pruned partition set feeds one file listing whose query-scoped file 
information serves both CBO cost estimation and scan split 
generation](/images/blogs/jd-apache-doris-lakehouse-query-optimization/shared-file-listing.png)
+
+Coordinating partition pruning, file enumeration, and scan planning extends 
optimization across the entire query preparation phase. The [Hive Catalog 
documentation](https://doris.apache.org/docs/dev/lakehouse/catalogs/hive-catalog/)
 explains the corresponding external data access capabilities in Doris.
+
+### Faster scanning and computation with vectorized execution
+
+After planning, file reads and operator execution determine throughput. JD.com 
optimized BE execution for complex predicates, multiple file formats, and 
frequently evaluated expressions.
+
+For expression evaluation, the team uses common subexpression elimination 
(CSE) to reduce repeated work. It adjusts predicate order based on evaluation 
cost and filtering effectiveness, uses runtime feedback to adapt selected 
predicate strategies, and reuses results for frequently called functions with 
constant arguments.
+
+For file reads, optimizations cover ORC, Parquet, and Hive Text/LZO. They 
reuse reader context, read columns on demand, reduce random access, and improve 
decompression and parsing. Concurrent file opening and reuse of HDFS 
connections further reduce scan overhead.
+
+For filtering and aggregation, eligible `COUNT(*)` and `MIN/MAX` queries use 
file statistics to avoid unnecessary reads. Selected function predicates are 
converted into column ranges that can be pushed down to finer-grained units 
such as row groups. **The original predicate remains for exact filtering when a 
range rewrite is not exact.**
+
+Adaptive batch sizes, byte-based shuffle flow control, and improvements to 
aggregation state and memory management reduce buffering and memory pressure 
for wide rows. These changes improve execution efficiency and stability under 
mixed workloads.
+
+![Eligible COUNT and MIN/MAX queries use metadata, while function-to-range 
rewrites support row-group pruning with residual predicates for 
correctness](/images/blogs/jd-apache-doris-lakehouse-query-optimization/scan-and-execution.png)
+
+Across FE planning and BE execution, these optimizations address task waits, 
metadata access, scanning, and computation as parts of the same query path.
+
+## 4. Compatibility and security governance
+
+A unified enterprise engine must fit existing SQL, storage, and security 
systems. JD.com extended its Doris integration in three areas.
+
+**SQL dialect compatibility.** The system converts both outer SQL and SQL 
stored in external views from a specified dialect, such as Spark SQL or Presto 
SQL, into Doris SQL for planning and execution. Within the supported 
compatibility scope, users can retain their existing SQL conventions.
+
+**Storage compatibility.** JD.com adapted the reading path for its customized 
Hudi LSM-tree architecture, including incremental queries over commit-time 
ranges and schema evolution handling. It added support for existing Hive RCFile 
and SequenceFile data and integrated native ChubaoFS reads for ORC, Parquet, 
and the Hudi native scan paths in use.
+
+**Security and auditability.** The query path associates business identity, 
request origin, and big data accounts. Unified authentication, credential 
management, and authorization control data access, including row-level and 
column-level permissions and data masking. Hive view authorization was also 
adapted so users can access authorized views according to the applicable rules. 
Linking business requests to underlying data access records improves 
traceability and auditing.
+
+These storage and governance adaptations describe JD.com's environment; check 
the official documentation for the capabilities supported by a particular Doris 
release.
+
+## 5. Next steps for AI agent workloads
+
+JD.com's architecture is evolving from several parallel engines toward a 
unified lakehouse query engine built on Doris. Multi-Catalog, Nereids, and 
vectorized execution let the team retain its lakehouse data while consolidating 
query compute and tuning it for production workloads.
+
+The team plans four further directions:
+
+1. **Agent-oriented workload optimization:** Build session-level caching and 
faster metadata access for agent workflows made up of multiple small queries, 
keeping end-to-end latency and cost manageable.
+2. **Predictive acceleration:** Use the predictability of daily traffic peaks 
and agent behavior for query result warm-up and execution plan reuse across 
queries.
+3. **Elastic lakehouse compute:** Use Doris's [compute-storage decoupled 
architecture](https://doris.apache.org/docs/dev/compute-storage-decoupled/intro/)
 and scaling capabilities to handle traffic peaks, moving capacity planning 
toward dynamic scheduling along the workload curve.
+4. **A shared semantic entry point:** Coordinate the engine with a Text-to-SQL 
semantic layer for schema-aware SQL generation and validation.
+
+These directions build on the same production requirement: one analytical 
foundation must serve interactive reports, large data quality scans, and 
continuous AI agent requests efficiently.
diff --git a/i18n/ja/code.json b/i18n/ja/code.json
index a5c80ded196..0bde0539829 100644
--- a/i18n/ja/code.json
+++ b/i18n/ja/code.json
@@ -4616,13 +4616,13 @@
     "message": "計画中"
   },
   "landing.roadmap.data.012": {
-    "message": "2026 年 9 月"
+    "message": "2026 年 11 月"
   },
   "landing.CommunityRoadmap.012": {
     "message": "マルチモーダルレイクハウスと検索機能の強化に重点を置いた機能リリースです。"
   },
   "landing.roadmap.data.013": {
-    "message": "2026 年 11 月"
+    "message": "2027 年 2 月"
   },
   "landing.CommunityRoadmap.013": {
     "message": "リアルタイム増分計算に重点を置いた機能リリースです。"
diff --git a/i18n/ko/code.json b/i18n/ko/code.json
index 351fefd9ddf..21a10ae90e2 100644
--- a/i18n/ko/code.json
+++ b/i18n/ko/code.json
@@ -4422,13 +4422,13 @@
     "message": "계획됨"
   },
   "landing.roadmap.data.012": {
-    "message": "2026년 9월"
+    "message": "2026년 11월"
   },
   "landing.CommunityRoadmap.012": {
     "message": "멀티모달 레이크하우스와 검색 기능 강화에 중점을 둔 기능 릴리스입니다."
   },
   "landing.roadmap.data.013": {
-    "message": "2026년 11월"
+    "message": "2027년 2월"
   },
   "landing.CommunityRoadmap.013": {
     "message": "실시간 증분 계산에 중점을 둔 기능 릴리스입니다."
diff --git a/i18n/ru/code.json b/i18n/ru/code.json
index 3d2bb7dde82..901a8054ab4 100644
--- a/i18n/ru/code.json
+++ b/i18n/ru/code.json
@@ -4422,13 +4422,13 @@
     "message": "Запланировано"
   },
   "landing.roadmap.data.012": {
-    "message": "Сентябрь 2026 г."
+    "message": "Ноябрь 2026 г."
   },
   "landing.CommunityRoadmap.012": {
     "message": "Функциональный релиз, посвящённый мультимодальному lakehouse и 
расширению поисковых возможностей."
   },
   "landing.roadmap.data.013": {
-    "message": "Ноябрь 2026 г."
+    "message": "Февраль 2027 г."
   },
   "landing.CommunityRoadmap.013": {
     "message": "Функциональный релиз, посвящённый инкрементальным вычислениям 
в реальном времени."
diff --git a/i18n/zh-CN/code.json b/i18n/zh-CN/code.json
index dbb7ebf181f..d17b59edac2 100644
--- a/i18n/zh-CN/code.json
+++ b/i18n/zh-CN/code.json
@@ -10843,13 +10843,13 @@
         "description": "Planned"
     },
     "landing.roadmap.data.012": {
-        "message": "2026 年 9 月",
-        "description": "Sep 2026"
-    },
-    "landing.roadmap.data.013": {
         "message": "2026 年 11 月",
         "description": "Nov 2026"
     },
+    "landing.roadmap.data.013": {
+        "message": "2027 年 2 月",
+        "description": "Feb 2027"
+    },
     "landing.events.status.upcoming": {
         "message": "即将举行"
     },
diff --git a/src/components/community-roadmap/CommunityRoadmap.tsx 
b/src/components/community-roadmap/CommunityRoadmap.tsx
index 68bf90dfad6..fed9095e720 100644
--- a/src/components/community-roadmap/CommunityRoadmap.tsx
+++ b/src/components/community-roadmap/CommunityRoadmap.tsx
@@ -76,14 +76,14 @@ const RELEASE_PLAN: ReleasePlanEntry[] = [
         version: '4.2',
         stage: 'planned',
         status: translate({id: "landing.roadmap.data.011", message: 
"Planned"}),
-        timing: translate({id: "landing.roadmap.data.012", message: "Sep 
2026"}),
+        timing: translate({id: "landing.roadmap.data.012", message: "Nov 
2026"}),
         description: translate({id: "landing.CommunityRoadmap.012", message: 
"A feature release focused on the multimodal lakehouse and stronger search 
capabilities."}),
     },
     {
         version: '5.0',
         stage: 'planned',
         status: translate({id: "landing.roadmap.data.011", message: 
"Planned"}),
-        timing: translate({id: "landing.roadmap.data.013", message: "Nov 
2026"}),
+        timing: translate({id: "landing.roadmap.data.013", message: "Feb 
2027"}),
         description: translate({id: "landing.CommunityRoadmap.013", message: 
"A feature release focused on real-time incremental computation."}),
     },
 ];
diff --git a/static/images/blogs/apache-doris-5-cdc-changelog/atomic-write.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/atomic-write.jpg
new file mode 100644
index 00000000000..99616a5baa2
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/atomic-write.jpg differ
diff --git 
a/static/images/blogs/apache-doris-5-cdc-changelog/campaign-spend-ivm.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/campaign-spend-ivm.jpg
new file mode 100644
index 00000000000..83e4ec1b278
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/campaign-spend-ivm.jpg differ
diff --git 
a/static/images/blogs/apache-doris-5-cdc-changelog/campaign-spend-table-stream.jpg
 
b/static/images/blogs/apache-doris-5-cdc-changelog/campaign-spend-table-stream.jpg
new file mode 100644
index 00000000000..ec279929368
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/campaign-spend-table-stream.jpg
 differ
diff --git 
a/static/images/blogs/apache-doris-5-cdc-changelog/changelog-read-modes.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/changelog-read-modes.jpg
new file mode 100644
index 00000000000..25321681209
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/changelog-read-modes.jpg 
differ
diff --git 
a/static/images/blogs/apache-doris-5-cdc-changelog/connector-architecture.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/connector-architecture.jpg
new file mode 100644
index 00000000000..6a875e8bd3c
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/connector-architecture.jpg 
differ
diff --git a/static/images/blogs/apache-doris-5-cdc-changelog/cover.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/cover.jpg
new file mode 100644
index 00000000000..11b4a19ab84
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/cover.jpg differ
diff --git 
a/static/images/blogs/apache-doris-5-cdc-changelog/doris-flink-cdc.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/doris-flink-cdc.jpg
new file mode 100644
index 00000000000..43a53f0a8ee
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/doris-flink-cdc.jpg differ
diff --git a/static/images/blogs/apache-doris-5-cdc-changelog/exactly-once.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/exactly-once.jpg
new file mode 100644
index 00000000000..e1c126723b1
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/exactly-once.jpg differ
diff --git 
a/static/images/blogs/apache-doris-5-cdc-changelog/parallel-readers.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/parallel-readers.jpg
new file mode 100644
index 00000000000..80ee49a17b3
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/parallel-readers.jpg differ
diff --git 
a/static/images/blogs/apache-doris-5-cdc-changelog/product-price-cdc.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/product-price-cdc.jpg
new file mode 100644
index 00000000000..7586344d78b
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/product-price-cdc.jpg differ
diff --git 
a/static/images/blogs/apache-doris-5-cdc-changelog/tso-commit-order.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/tso-commit-order.jpg
new file mode 100644
index 00000000000..f1767875158
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/tso-commit-order.jpg differ
diff --git 
a/static/images/blogs/apache-doris-5-cdc-changelog/wait-before-read.jpg 
b/static/images/blogs/apache-doris-5-cdc-changelog/wait-before-read.jpg
new file mode 100644
index 00000000000..640c626280a
Binary files /dev/null and 
b/static/images/blogs/apache-doris-5-cdc-changelog/wait-before-read.jpg differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/cell-architecture.jpg
 
b/static/images/blogs/hubspot-apache-doris-search-analytics/cell-architecture.jpg
new file mode 100644
index 00000000000..38cab486698
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/cell-architecture.jpg
 differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/cover.jpg 
b/static/images/blogs/hubspot-apache-doris-search-analytics/cover.jpg
new file mode 100644
index 00000000000..ad653ff301a
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/cover.jpg differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/crm-data-model.jpg 
b/static/images/blogs/hubspot-apache-doris-search-analytics/crm-data-model.jpg
new file mode 100644
index 00000000000..dc710de57db
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/crm-data-model.jpg 
differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/crm-query-challenges.jpg
 
b/static/images/blogs/hubspot-apache-doris-search-analytics/crm-query-challenges.jpg
new file mode 100644
index 00000000000..6b8519d58c8
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/crm-query-challenges.jpg
 differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/doris-capabilities.jpg
 
b/static/images/blogs/hubspot-apache-doris-search-analytics/doris-capabilities.jpg
new file mode 100644
index 00000000000..583daad259d
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/doris-capabilities.jpg
 differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/global-rollout.jpg 
b/static/images/blogs/hubspot-apache-doris-search-analytics/global-rollout.jpg
new file mode 100644
index 00000000000..d8577aceb97
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/global-rollout.jpg 
differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/p50-query-latency.jpg
 
b/static/images/blogs/hubspot-apache-doris-search-analytics/p50-query-latency.jpg
new file mode 100644
index 00000000000..de985659bad
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/p50-query-latency.jpg
 differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/priority-ingestion.jpg
 
b/static/images/blogs/hubspot-apache-doris-search-analytics/priority-ingestion.jpg
new file mode 100644
index 00000000000..0f4b99d6af3
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/priority-ingestion.jpg
 differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/query-fan-out.jpg 
b/static/images/blogs/hubspot-apache-doris-search-analytics/query-fan-out.jpg
new file mode 100644
index 00000000000..d310d4d0619
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/query-fan-out.jpg 
differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/talk-video-poster.jpg
 
b/static/images/blogs/hubspot-apache-doris-search-analytics/talk-video-poster.jpg
new file mode 100644
index 00000000000..f0cd0512864
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/talk-video-poster.jpg
 differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/variant-typed-columns.jpg
 
b/static/images/blogs/hubspot-apache-doris-search-analytics/variant-typed-columns.jpg
new file mode 100644
index 00000000000..e0bba53f95b
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/variant-typed-columns.jpg
 differ
diff --git 
a/static/images/blogs/hubspot-apache-doris-search-analytics/video-poster.jpg 
b/static/images/blogs/hubspot-apache-doris-search-analytics/video-poster.jpg
new file mode 100644
index 00000000000..34ff3abb21f
Binary files /dev/null and 
b/static/images/blogs/hubspot-apache-doris-search-analytics/video-poster.jpg 
differ
diff --git 
a/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/architecture-evolution.png
 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/architecture-evolution.png
new file mode 100644
index 00000000000..19d38090d80
Binary files /dev/null and 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/architecture-evolution.png
 differ
diff --git 
a/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/cover.jpg 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/cover.jpg
new file mode 100644
index 00000000000..c3b67b83ba3
Binary files /dev/null and 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/cover.jpg 
differ
diff --git 
a/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/partition-pruning.png
 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/partition-pruning.png
new file mode 100644
index 00000000000..25704bed1d7
Binary files /dev/null and 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/partition-pruning.png
 differ
diff --git 
a/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/pull-push-comparison.png
 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/pull-push-comparison.png
new file mode 100644
index 00000000000..76f97c6f4f3
Binary files /dev/null and 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/pull-push-comparison.png
 differ
diff --git 
a/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/scan-and-execution.png
 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/scan-and-execution.png
new file mode 100644
index 00000000000..a3568cabd8c
Binary files /dev/null and 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/scan-and-execution.png
 differ
diff --git 
a/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/shared-file-listing.png
 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/shared-file-listing.png
new file mode 100644
index 00000000000..63e61929b0e
Binary files /dev/null and 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/shared-file-listing.png
 differ
diff --git 
a/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/split-scheduling.png
 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/split-scheduling.png
new file mode 100644
index 00000000000..33937586c22
Binary files /dev/null and 
b/static/images/blogs/jd-apache-doris-lakehouse-query-optimization/split-scheduling.png
 differ
diff --git a/translations/pages/state.json b/translations/pages/state.json
index 4e1fef6fd81..5b2519eaf37 100644
--- a/translations/pages/state.json
+++ b/translations/pages/state.json
@@ -59,7 +59,7 @@
         "homepage"
       ],
       "sourceHash": 
"f5a53c5f8581acbd82250258ea55528f2d66cb5d037a576c721c20e5a372929c",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewStatus": "machine"
     },
     {
@@ -120,7 +120,7 @@
         "homepage"
       ],
       "sourceHash": 
"f5a53c5f8581acbd82250258ea55528f2d66cb5d037a576c721c20e5a372929c",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd",
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907",
       "reviewStatus": "machine"
     },
     {
@@ -181,7 +181,7 @@
         "homepage"
       ],
       "sourceHash": 
"f5a53c5f8581acbd82250258ea55528f2d66cb5d037a576c721c20e5a372929c",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f",
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6",
       "reviewStatus": "machine"
     },
     {
@@ -242,7 +242,7 @@
         "homepage"
       ],
       "sourceHash": 
"f5a53c5f8581acbd82250258ea55528f2d66cb5d037a576c721c20e5a372929c",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f",
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2",
       "reviewStatus": "machine"
     },
     {
@@ -270,7 +270,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"337dfd3f9d86e98e05591d6fdf27f5d460fabb70298294ad7f770a74d74c9dff",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -297,7 +297,7 @@
         "i18n/ja/code.json"
       ],
       "sourceHash": 
"337dfd3f9d86e98e05591d6fdf27f5d460fabb70298294ad7f770a74d74c9dff",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd",
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -327,7 +327,7 @@
         "i18n/ko/code.json"
       ],
       "sourceHash": 
"337dfd3f9d86e98e05591d6fdf27f5d460fabb70298294ad7f770a74d74c9dff",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f",
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -357,7 +357,7 @@
         "i18n/ru/code.json"
       ],
       "sourceHash": 
"337dfd3f9d86e98e05591d6fdf27f5d460fabb70298294ad7f770a74d74c9dff",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f",
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -379,7 +379,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"faa2dfb60b7b2f2f263f67eb4dd791feb6b1c763259ce1aacb0280c3f2d1184c",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -397,7 +397,7 @@
         "i18n/ja/code.json"
       ],
       "sourceHash": 
"faa2dfb60b7b2f2f263f67eb4dd791feb6b1c763259ce1aacb0280c3f2d1184c",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd",
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -418,7 +418,7 @@
         "i18n/ko/code.json"
       ],
       "sourceHash": 
"faa2dfb60b7b2f2f263f67eb4dd791feb6b1c763259ce1aacb0280c3f2d1184c",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f",
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -439,7 +439,7 @@
         "i18n/ru/code.json"
       ],
       "sourceHash": 
"faa2dfb60b7b2f2f263f67eb4dd791feb6b1c763259ce1aacb0280c3f2d1184c",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f",
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -461,7 +461,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"0e443a2d62bcd13a7bd71a95a3aad9a856a8789f5c423e533ba0f75fb9c4909b",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -479,7 +479,7 @@
         "i18n/ja/code.json"
       ],
       "sourceHash": 
"0e443a2d62bcd13a7bd71a95a3aad9a856a8789f5c423e533ba0f75fb9c4909b",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd",
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "derivedDependencies": [
@@ -503,7 +503,7 @@
         "i18n/ko/code.json"
       ],
       "sourceHash": 
"0e443a2d62bcd13a7bd71a95a3aad9a856a8789f5c423e533ba0f75fb9c4909b",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f",
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "derivedDependencies": [
@@ -527,7 +527,7 @@
         "i18n/ru/code.json"
       ],
       "sourceHash": 
"0e443a2d62bcd13a7bd71a95a3aad9a856a8789f5c423e533ba0f75fb9c4909b",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f",
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "derivedDependencies": [
@@ -691,7 +691,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"cc12416cf9494de15597003e40491c91a2197b819a99dc0d293cb0cf07660438",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -853,7 +853,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"cc12416cf9494de15597003e40491c91a2197b819a99dc0d293cb0cf07660438",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P05",
@@ -1014,7 +1014,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"cc12416cf9494de15597003e40491c91a2197b819a99dc0d293cb0cf07660438",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P05",
@@ -1175,7 +1175,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"cc12416cf9494de15597003e40491c91a2197b819a99dc0d293cb0cf07660438",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P06",
@@ -1198,7 +1198,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"572f5460f3e88a1d45232ffa837c236f06d2a8f18132fcd63cade5f19d831500",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -1221,7 +1221,7 @@
         "i18n/ja/code.json"
       ],
       "sourceHash": 
"572f5460f3e88a1d45232ffa837c236f06d2a8f18132fcd63cade5f19d831500",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd",
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1247,7 +1247,7 @@
         "i18n/ko/code.json"
       ],
       "sourceHash": 
"572f5460f3e88a1d45232ffa837c236f06d2a8f18132fcd63cade5f19d831500",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f",
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1273,7 +1273,7 @@
         "i18n/ru/code.json"
       ],
       "sourceHash": 
"572f5460f3e88a1d45232ffa837c236f06d2a8f18132fcd63cade5f19d831500",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f",
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1300,7 +1300,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"82b97c655120ad6aafaa445bc35f4b6a48330ad70aba5e8128c998c7ca3dd92f",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -1323,7 +1323,7 @@
         "i18n/ja/code.json"
       ],
       "sourceHash": 
"82b97c655120ad6aafaa445bc35f4b6a48330ad70aba5e8128c998c7ca3dd92f",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd",
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1349,7 +1349,7 @@
         "i18n/ko/code.json"
       ],
       "sourceHash": 
"82b97c655120ad6aafaa445bc35f4b6a48330ad70aba5e8128c998c7ca3dd92f",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f",
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1375,7 +1375,7 @@
         "i18n/ru/code.json"
       ],
       "sourceHash": 
"82b97c655120ad6aafaa445bc35f4b6a48330ad70aba5e8128c998c7ca3dd92f",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f",
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1402,7 +1402,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"41300ff30c8bfa4923eadc74667c4195cc246a20fb823c4edb4f3aaa97124aef",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -1425,7 +1425,7 @@
         "i18n/ja/code.json"
       ],
       "sourceHash": 
"41300ff30c8bfa4923eadc74667c4195cc246a20fb823c4edb4f3aaa97124aef",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd",
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1451,7 +1451,7 @@
         "i18n/ko/code.json"
       ],
       "sourceHash": 
"41300ff30c8bfa4923eadc74667c4195cc246a20fb823c4edb4f3aaa97124aef",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f",
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1477,7 +1477,7 @@
         "i18n/ru/code.json"
       ],
       "sourceHash": 
"41300ff30c8bfa4923eadc74667c4195cc246a20fb823c4edb4f3aaa97124aef",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f",
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1501,7 +1501,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"15d1b62c09dd2e12754c4219df7a67b426d8088d7b3506837e12171349acec00",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -1521,7 +1521,7 @@
         "i18n/ja/code.json"
       ],
       "sourceHash": 
"15d1b62c09dd2e12754c4219df7a67b426d8088d7b3506837e12171349acec00",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd",
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1544,7 +1544,7 @@
         "i18n/ko/code.json"
       ],
       "sourceHash": 
"15d1b62c09dd2e12754c4219df7a67b426d8088d7b3506837e12171349acec00",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f",
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1567,7 +1567,7 @@
         "i18n/ru/code.json"
       ],
       "sourceHash": 
"15d1b62c09dd2e12754c4219df7a67b426d8088d7b3506837e12171349acec00",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f",
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2",
       "reviewStatus": "machine",
       "compatibilitySource": "Existing seven marketing pages at 
bb7e86a7ff7b9232af24090928cfbc9a87d8a3b2",
       "reviewedSourceCommit": "2df4bc3783d68b5d1b9b50cca4ffda6f8046b259",
@@ -1598,7 +1598,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"9a606e29b717c97f10e92019c0449174ad2dc7f411a28e5e921abecff3576cb4",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "df07fea7243b149566236fc0932304564fab2d25"
     },
     {
@@ -1632,7 +1632,7 @@
       ],
       "reviewedSourceCommit": "df07fea7243b149566236fc0932304564fab2d25",
       "sourceHash": 
"9a606e29b717c97f10e92019c0449174ad2dc7f411a28e5e921abecff3576cb4",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P10",
@@ -1665,7 +1665,7 @@
       ],
       "reviewedSourceCommit": "df07fea7243b149566236fc0932304564fab2d25",
       "sourceHash": 
"9a606e29b717c97f10e92019c0449174ad2dc7f411a28e5e921abecff3576cb4",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P10",
@@ -1698,7 +1698,7 @@
       ],
       "reviewedSourceCommit": "df07fea7243b149566236fc0932304564fab2d25",
       "sourceHash": 
"9a606e29b717c97f10e92019c0449174ad2dc7f411a28e5e921abecff3576cb4",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P11",
@@ -1725,7 +1725,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"eca1dd2eaf22825059040986b901880e13416a8ef56279c66e7516196e0b51f6",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "5264923f07b0cb362febce45b5d62abd94966de4"
     },
     {
@@ -1757,7 +1757,7 @@
       ],
       "reviewedSourceCommit": "5264923f07b0cb362febce45b5d62abd94966de4",
       "sourceHash": 
"eca1dd2eaf22825059040986b901880e13416a8ef56279c66e7516196e0b51f6",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P11",
@@ -1788,7 +1788,7 @@
       ],
       "reviewedSourceCommit": "5264923f07b0cb362febce45b5d62abd94966de4",
       "sourceHash": 
"eca1dd2eaf22825059040986b901880e13416a8ef56279c66e7516196e0b51f6",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P11",
@@ -1819,7 +1819,7 @@
       ],
       "reviewedSourceCommit": "5264923f07b0cb362febce45b5d62abd94966de4",
       "sourceHash": 
"eca1dd2eaf22825059040986b901880e13416a8ef56279c66e7516196e0b51f6",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P12",
@@ -1873,7 +1873,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"fbc29f6ab62e9b5ec55d2d2c689d881ef94cb313ef4de07026ca70ca30bae97c",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "5264923f07b0cb362febce45b5d62abd94966de4"
     },
     {
@@ -1932,7 +1932,7 @@
       ],
       "reviewedSourceCommit": "5264923f07b0cb362febce45b5d62abd94966de4",
       "sourceHash": 
"fbc29f6ab62e9b5ec55d2d2c689d881ef94cb313ef4de07026ca70ca30bae97c",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P12",
@@ -1990,7 +1990,7 @@
       ],
       "reviewedSourceCommit": "5264923f07b0cb362febce45b5d62abd94966de4",
       "sourceHash": 
"fbc29f6ab62e9b5ec55d2d2c689d881ef94cb313ef4de07026ca70ca30bae97c",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P12",
@@ -2048,7 +2048,7 @@
       ],
       "reviewedSourceCommit": "5264923f07b0cb362febce45b5d62abd94966de4",
       "sourceHash": 
"fbc29f6ab62e9b5ec55d2d2c689d881ef94cb313ef4de07026ca70ca30bae97c",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P13",
@@ -2063,8 +2063,8 @@
         "i18n/zh-CN/code.json"
       ],
       "reviewStatus": "machine",
-      "sourceHash": 
"04aea9fc522482abd7826e6bc880d753a67c298e71a743cb8b660ba599924aa3",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "sourceHash": 
"d77397afe1f79bd1f51c2219630c353a63b8091143a943a8b705931a755341a0",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -2084,8 +2084,8 @@
         "landing"
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
-      "sourceHash": 
"04aea9fc522482abd7826e6bc880d753a67c298e71a743cb8b660ba599924aa3",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "sourceHash": 
"d77397afe1f79bd1f51c2219630c353a63b8091143a943a8b705931a755341a0",
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P13",
@@ -2104,8 +2104,8 @@
         "landing"
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
-      "sourceHash": 
"04aea9fc522482abd7826e6bc880d753a67c298e71a743cb8b660ba599924aa3",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "sourceHash": 
"d77397afe1f79bd1f51c2219630c353a63b8091143a943a8b705931a755341a0",
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P13",
@@ -2124,8 +2124,8 @@
         "landing"
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
-      "sourceHash": 
"04aea9fc522482abd7826e6bc880d753a67c298e71a743cb8b660ba599924aa3",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "sourceHash": 
"d77397afe1f79bd1f51c2219630c353a63b8091143a943a8b705931a755341a0",
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P14",
@@ -2160,7 +2160,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"19ac30159720760fb2140606d3a5f145d7cf317d10436f362b7854a896aaded9",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "bd675d25613a69a75e5f97196d6d32f2fd05a0c3"
     },
     {
@@ -2200,7 +2200,7 @@
       ],
       "reviewedSourceCommit": "bd675d25613a69a75e5f97196d6d32f2fd05a0c3",
       "sourceHash": 
"19ac30159720760fb2140606d3a5f145d7cf317d10436f362b7854a896aaded9",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P14",
@@ -2239,7 +2239,7 @@
       ],
       "reviewedSourceCommit": "bd675d25613a69a75e5f97196d6d32f2fd05a0c3",
       "sourceHash": 
"19ac30159720760fb2140606d3a5f145d7cf317d10436f362b7854a896aaded9",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P14",
@@ -2278,7 +2278,7 @@
       ],
       "reviewedSourceCommit": "bd675d25613a69a75e5f97196d6d32f2fd05a0c3",
       "sourceHash": 
"19ac30159720760fb2140606d3a5f145d7cf317d10436f362b7854a896aaded9",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P15",
@@ -2300,7 +2300,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"bbf902c3ffce41a8f90113d196a8b1cf48b9c9881b5a8fe0592240e9cd2ef16f",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -2327,7 +2327,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"bbf902c3ffce41a8f90113d196a8b1cf48b9c9881b5a8fe0592240e9cd2ef16f",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P15",
@@ -2353,7 +2353,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"bbf902c3ffce41a8f90113d196a8b1cf48b9c9881b5a8fe0592240e9cd2ef16f",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P15",
@@ -2379,7 +2379,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"bbf902c3ffce41a8f90113d196a8b1cf48b9c9881b5a8fe0592240e9cd2ef16f",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P16",
@@ -2404,7 +2404,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"ab6284412105c7267bf08532153b58e1b420dfd681da6a9e2952fa4387f0bec3",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -2434,7 +2434,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"ab6284412105c7267bf08532153b58e1b420dfd681da6a9e2952fa4387f0bec3",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P16",
@@ -2463,7 +2463,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"ab6284412105c7267bf08532153b58e1b420dfd681da6a9e2952fa4387f0bec3",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P16",
@@ -2492,7 +2492,7 @@
       ],
       "reviewedSourceCommit": "3f9be0688303724a81180847311584185ee1baa7",
       "sourceHash": 
"ab6284412105c7267bf08532153b58e1b420dfd681da6a9e2952fa4387f0bec3",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P17",
@@ -2517,7 +2517,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"cd29749441d766c54f2d43cbb0c70e1ce881406430e760fda796deb01e3626d8",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -2547,7 +2547,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"cd29749441d766c54f2d43cbb0c70e1ce881406430e760fda796deb01e3626d8",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P17",
@@ -2576,7 +2576,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"cd29749441d766c54f2d43cbb0c70e1ce881406430e760fda796deb01e3626d8",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P17",
@@ -2605,7 +2605,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"cd29749441d766c54f2d43cbb0c70e1ce881406430e760fda796deb01e3626d8",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P18",
@@ -2630,7 +2630,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"f694e146285128c00fb1a8987b4c1060fb5757015e1bffc308b6516bdfc3c6fa",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -2660,7 +2660,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"f694e146285128c00fb1a8987b4c1060fb5757015e1bffc308b6516bdfc3c6fa",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P18",
@@ -2689,7 +2689,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"f694e146285128c00fb1a8987b4c1060fb5757015e1bffc308b6516bdfc3c6fa",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P18",
@@ -2718,7 +2718,7 @@
       ],
       "reviewedSourceCommit": "3f9be0688303724a81180847311584185ee1baa7",
       "sourceHash": 
"f694e146285128c00fb1a8987b4c1060fb5757015e1bffc308b6516bdfc3c6fa",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P19",
@@ -2743,7 +2743,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"24161716f6bbce2657bbea22222bee874084d111cac639b6a0f73e4765e16398",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "3a9e30380a8f000d7583b107059af36f885af6ac"
     },
     {
@@ -2773,7 +2773,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"24161716f6bbce2657bbea22222bee874084d111cac639b6a0f73e4765e16398",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P19",
@@ -2802,7 +2802,7 @@
       ],
       "reviewedSourceCommit": "84fc102161d192a2ef7547a034db5035b21fc12d",
       "sourceHash": 
"24161716f6bbce2657bbea22222bee874084d111cac639b6a0f73e4765e16398",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P19",
@@ -2831,7 +2831,7 @@
       ],
       "reviewedSourceCommit": "3f9be0688303724a81180847311584185ee1baa7",
       "sourceHash": 
"24161716f6bbce2657bbea22222bee874084d111cac639b6a0f73e4765e16398",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P20",
@@ -2858,7 +2858,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"6fe0e95a478c3fca62da5d3d0f30f91bbeeb5a72ff8a7ff4c73bab56d081e215",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "83db37675df50061dbf657a93706b920ffccbcbc"
     },
     {
@@ -2890,7 +2890,7 @@
       ],
       "reviewedSourceCommit": "83db37675df50061dbf657a93706b920ffccbcbc",
       "sourceHash": 
"6fe0e95a478c3fca62da5d3d0f30f91bbeeb5a72ff8a7ff4c73bab56d081e215",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P20",
@@ -2921,7 +2921,7 @@
       ],
       "reviewedSourceCommit": "83db37675df50061dbf657a93706b920ffccbcbc",
       "sourceHash": 
"6fe0e95a478c3fca62da5d3d0f30f91bbeeb5a72ff8a7ff4c73bab56d081e215",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P20",
@@ -2952,7 +2952,7 @@
       ],
       "reviewedSourceCommit": "83db37675df50061dbf657a93706b920ffccbcbc",
       "sourceHash": 
"6fe0e95a478c3fca62da5d3d0f30f91bbeeb5a72ff8a7ff4c73bab56d081e215",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:P21",
@@ -2990,7 +2990,7 @@
       ],
       "reviewStatus": "machine",
       "sourceHash": 
"adbbc6ec57dabb8bf267b547ebd87a096031e99fd69ecc2697ddb1c27d665c29",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewedSourceCommit": "83db37675df50061dbf657a93706b920ffccbcbc"
     },
     {
@@ -3033,7 +3033,7 @@
       ],
       "reviewedSourceCommit": "83db37675df50061dbf657a93706b920ffccbcbc",
       "sourceHash": 
"adbbc6ec57dabb8bf267b547ebd87a096031e99fd69ecc2697ddb1c27d665c29",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd"
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907"
     },
     {
       "contentId": "page:P21",
@@ -3075,7 +3075,7 @@
       ],
       "reviewedSourceCommit": "83db37675df50061dbf657a93706b920ffccbcbc",
       "sourceHash": 
"adbbc6ec57dabb8bf267b547ebd87a096031e99fd69ecc2697ddb1c27d665c29",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f"
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6"
     },
     {
       "contentId": "page:P21",
@@ -3117,7 +3117,7 @@
       ],
       "reviewedSourceCommit": "83db37675df50061dbf657a93706b920ffccbcbc",
       "sourceHash": 
"adbbc6ec57dabb8bf267b547ebd87a096031e99fd69ecc2697ddb1c27d665c29",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f"
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2"
     },
     {
       "contentId": "page:archived-docs",
@@ -3138,7 +3138,7 @@
         "docs.archive.title"
       ],
       "sourceHash": 
"0df5166f5ec3532c2dd3a4e3a2d591dbbb10b0e66537d9bd24d8c26cf7592c83",
-      "targetHash": 
"68e14a5f0b2d5ecaa6c5e618253a28d07776f87b9353de05b55f89efa8dc3d8f",
+      "targetHash": 
"7c9ca6a9a16a91c328a7fa370f6f72fab7aff6b20cd56ee76953d199a12abaef",
       "reviewStatus": "machine"
     },
     {
@@ -3160,7 +3160,7 @@
         "docs.archive.title"
       ],
       "sourceHash": 
"0df5166f5ec3532c2dd3a4e3a2d591dbbb10b0e66537d9bd24d8c26cf7592c83",
-      "targetHash": 
"0c37b2947c8196e2d8fd4e66f587d0ea0a16f7c41e92e9ef3700d79c0fbaf1dd",
+      "targetHash": 
"7aad8ac06bc3da1c6c4927bef83fed93d9533a697e291ce9f678f6b7b8c57907",
       "reviewStatus": "machine"
     },
     {
@@ -3182,7 +3182,7 @@
         "docs.archive.title"
       ],
       "sourceHash": 
"0df5166f5ec3532c2dd3a4e3a2d591dbbb10b0e66537d9bd24d8c26cf7592c83",
-      "targetHash": 
"47347659487a58617753d2f36044472c49c6256fbe74ccec79645617d8bfaa1f",
+      "targetHash": 
"ae5fdf1fcb67d69c33d01546899adea4f5f7a3156c2fffc4c6450e97c79f29b6",
       "reviewStatus": "machine"
     },
     {
@@ -3204,7 +3204,7 @@
         "docs.archive.title"
       ],
       "sourceHash": 
"0df5166f5ec3532c2dd3a4e3a2d591dbbb10b0e66537d9bd24d8c26cf7592c83",
-      "targetHash": 
"b5ad97287db88192ccdb7ce74d645736c5e8edf2384f0c7b65653ba9b8f5476f",
+      "targetHash": 
"82c6e8acdcc392945b7a433f5d9b06cd6ef7da1e71f630ff091d21c4329997d2",
       "reviewStatus": "machine"
     }
   ]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to