You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hudi.apache.org by xu...@apache.org on 2025/11/08 21:28:26 UTC
(hudi) branch asf-site updated: chore(site): 'Learn' page should have a left nav bar like 'Community' and 'Contribute' (#14221)
This is an automated email from the ASF dual-hosted git repository.
xushiyan pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/hudi.git
The following commit(s) were added to refs/heads/asf-site by this push:
new 34f4d7bd9433 chore(site): 'Learn' page should have a left nav bar like 'Community' and 'Contribute' (#14221)
34f4d7bd9433 is described below
commit 34f4d7bd9433c5bccb088a4fac0288b85d6e8537
Author: Ranga Reddy <ra...@gmail.com>
AuthorDate: Sun Nov 9 02:58:19 2025 +0530
chore(site): 'Learn' page should have a left nav bar like 'Community' and 'Contribute' (#14221)
---
website/docusaurus.config.js | 41 +++--
website/learn/blog.md | 11 ++
website/learn/faq.md | 12 ++
website/learn/index.md | 16 --
website/{src/pages => learn}/talks.md | 0
website/{src/pages => learn}/tech-specs-1point0.md | 8 +-
website/{src/pages => learn}/tech-specs.md | 0
website/{src/pages => }/learn/tutorial-series.md | 0
website/learn/videos.md | 12 ++
website/releases/release-1.0.0-beta1.md | 4 +-
website/releases/release-1.0.0-beta2.md | 2 +-
website/releases/release-1.0.0.md | 6 +-
website/sidebarsLearn.js | 51 ++++++
website/src/components/BlogList/index.js | 164 +++++++++++++++++
.../src/components/ContentList/styles.module.css | 199 +++++++++++++++++++++
website/src/components/FAQList/index.js | 72 ++++++++
website/src/components/VideoList/index.js | 173 ++++++++++++++++++
website/src/pages/faq.md | 16 --
website/src/pages/faq/design_and_concepts.md | 2 +-
website/src/pages/faq/storage.md | 2 +-
website/versioned_docs/version-0.14.0/faq.md | 2 +-
.../version-0.14.1/faq_design_and_concepts.md | 2 +-
.../versioned_docs/version-0.14.1/faq_storage.md | 2 +-
.../version-0.15.0/faq_design_and_concepts.md | 2 +-
.../versioned_docs/version-0.15.0/faq_storage.md | 2 +-
.../version-1.0.0/faq_design_and_concepts.md | 2 +-
.../versioned_docs/version-1.0.0/faq_storage.md | 2 +-
.../version-1.0.1/faq_design_and_concepts.md | 2 +-
.../versioned_docs/version-1.0.1/faq_storage.md | 2 +-
.../version-1.0.2/faq_design_and_concepts.md | 2 +-
.../versioned_docs/version-1.0.2/faq_storage.md | 2 +-
31 files changed, 746 insertions(+), 67 deletions(-)
diff --git a/website/docusaurus.config.js b/website/docusaurus.config.js
index 1066e8b8f002..90b97cacb29b 100644
--- a/website/docusaurus.config.js
+++ b/website/docusaurus.config.js
@@ -91,6 +91,7 @@ module.exports = {
id: "learn",
path: "learn",
routeBasePath: "learn",
+ sidebarPath: require.resolve("./sidebarsLearn.js"),
showLastUpdateAuthor: false,
showLastUpdateTime: false,
},
@@ -107,6 +108,22 @@ module.exports = {
}
},
redirects: [
+ {
+ from: "/faq",
+ to: "/learn/faq",
+ },
+ {
+ from: "/talks",
+ to: "/learn/talks",
+ },
+ {
+ from: "/tech-specs",
+ to: "/learn/tech-specs",
+ },
+ {
+ from: "/tech-specs-1point0",
+ to: "/learn/tech-specs-1point0",
+ },
{
from: [
"/docs/contribute",
@@ -172,28 +189,28 @@ module.exports = {
to: "/learn/tutorial-series",
},
{
- label: "Talks",
- to: "talks",
+ label: "Blogs",
+ to: "/learn/blog",
},
{
- label: "Blog",
- to: "/blog",
+ label: "Talks",
+ to: "/learn/talks",
},
{
label: "Video Guides",
- to: "videos",
+ to: "/learn/videos",
},
{
label: "FAQ",
- href: "/faq",
+ to: "/learn/faq",
},
{
label: "Tech Specs",
- href: "/tech-specs",
+ to: "/learn/tech-specs",
},
{
label: "Tech Specs 1.0",
- href: "/tech-specs-1point0",
+ to: "/learn/tech-specs-1point0",
},
],
},
@@ -336,19 +353,19 @@ module.exports = {
},
{
label: "Blog",
- to: "/blog",
+ to: "/learn/blog",
},
{
label: "Talks",
- to: "talks",
+ to: "/learn/talks",
},
{
label: "Video Guides",
- to: "videos",
+ to: "/learn/videos",
},
{
label: "FAQ",
- href: "/faq",
+ to: "/learn/faq",
},
],
},
diff --git a/website/learn/blog.md b/website/learn/blog.md
new file mode 100644
index 000000000000..7bd0edc50e8c
--- /dev/null
+++ b/website/learn/blog.md
@@ -0,0 +1,11 @@
+---
+title: "Blogs"
+---
+
+import BlogList from '@site/src/components/BlogList';
+
+# Blogs
+
+Welcome to Apache Hudi blogs! Here you'll find the latest articles, tutorials, and updates from the Hudi community.
+
+<BlogList />
diff --git a/website/learn/faq.md b/website/learn/faq.md
new file mode 100644
index 000000000000..f23ff5afd379
--- /dev/null
+++ b/website/learn/faq.md
@@ -0,0 +1,12 @@
+---
+title: "FAQ"
+---
+
+import FAQList from '@site/src/components/FAQList';
+
+# FAQ
+
+Welcome to the Apache Hudi FAQ! Find answers to frequently asked questions about Hudi.
+
+<FAQList />
+
diff --git a/website/learn/index.md b/website/learn/index.md
deleted file mode 100644
index d307645e06eb..000000000000
--- a/website/learn/index.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-id: index
-title: Learning Hub
-sidebar_label: Overview
-description: Entry point for Hudi learning resources, including the Tutorial Series, Talks, Blogs, Videos, and FAQ.
----
-
-Welcome to Apache Hudi's learning hub.
-
-- Start with the quick-start guide in the docs: [/docs/quick-start-guide](/docs/quick-start-guide)
-- Explore the tutorial series: [/learn/tutorial-series](/learn/tutorial-series)
-- Browse the blogs: [/blog](/blog)
-- Watch video guides: [/videos](/videos)
-- Check the FAQ: [/faq](/faq)
-
-If you're looking to contribute or join community events, see [/community/get-involved](/community/get-involved).
diff --git a/website/src/pages/talks.md b/website/learn/talks.md
similarity index 100%
rename from website/src/pages/talks.md
rename to website/learn/talks.md
diff --git a/website/src/pages/tech-specs-1point0.md b/website/learn/tech-specs-1point0.md
similarity index 99%
rename from website/src/pages/tech-specs-1point0.md
rename to website/learn/tech-specs-1point0.md
index 917c2f552983..fccdbf9a6a20 100644
--- a/website/src/pages/tech-specs-1point0.md
+++ b/website/learn/tech-specs-1point0.md
@@ -1,4 +1,4 @@
-# Apache Hudi Technical Specification
+# Apache Hudi Technical Specification 1.0
| **Syntax** | **Description** |
| ---|-----------------|
@@ -6,7 +6,7 @@
| [Table Version](https://github.com/apache/hudi/blob/master/hudi-common/src/main/java/org/apache/hudi/common/table/HoodieTableVersion.java#L29) | 8 |
:::note
-Please check the specification for versions prior to 1.0 [here](/tech-specs).
+Please check the specification for versions prior to 1.0 [here](/learn/tech-specs).
:::
Hudi brings database capabilities (tables, transactions, mutability, indexes, storage layouts) along with an incremental stream processing model (incremental merges, change streams, out-of-order data)
@@ -154,7 +154,7 @@ Hudi storage format supports two table types offering different trade-offs betwe
| **Table Type** | **Description** |
| ---| --- |
| Copy-on-Write (CoW) | Data is stored entirely in base files, optimized for read performance and ideal for slow changing datasets. Any updates, inserts, deletes accordingly produce new base files for each write operation. Change data is still stored as log files associated with the base files. |
-| Merge-on-Read (MoR) | Data is stored in a combination of base and log files, optimized to [balance the write and read performance](http://##balancing-write-and-query-performance) and ideal for frequently changing datasets |
+| Merge-on-Read (MoR) | Data is stored in a combination of base and log files, optimized to [Balancing Write and Read Performance](#balancing-write-and-read-performance) and ideal for frequently changing datasets |
Readers need to then satisfy different query types on these tables.
@@ -369,7 +369,7 @@ stored with the actual record to avoid re-computation.
| Hudi meta-fields | Description |
| ---| --- |
-| \_hoodie\_commit\_time | This field contains the commit timestamp in the [timeline](http://#transaction-log-timeline) that created this record. This enables granular, record-level history tracking on the table, much like database change-data-capture. |
+| \_hoodie\_commit\_time | This field contains the commit timestamp in the timeline that created this record. This enables granular, record-level history tracking on the table, much like database change-data-capture. |
| \_hoodie\_commit\_seqno | This field contains a unique sequence number for each record within each transaction. This serves much like offsets in Apache Kafka topics, to enable generating streams out of tables. |
| \_hoodie\_record\_key | Unique record key identifying the record within the partition. Key is materialized to avoid changes to key field(s) resulting in violating unique constraints maintained within a table. |
| \_hoodie\_partition\_path | Partition path under which the record is organized into. |
diff --git a/website/src/pages/tech-specs.md b/website/learn/tech-specs.md
similarity index 100%
rename from website/src/pages/tech-specs.md
rename to website/learn/tech-specs.md
diff --git a/website/src/pages/learn/tutorial-series.md b/website/learn/tutorial-series.md
similarity index 100%
rename from website/src/pages/learn/tutorial-series.md
rename to website/learn/tutorial-series.md
diff --git a/website/learn/videos.md b/website/learn/videos.md
new file mode 100644
index 000000000000..ab87b9723c5b
--- /dev/null
+++ b/website/learn/videos.md
@@ -0,0 +1,12 @@
+---
+title: "Video Guides"
+---
+
+import VideoList from '@site/src/components/VideoList';
+
+# Video Guides
+
+Welcome to the Apache Hudi Video Guides! Watch tutorials, talks, and demos to learn more about Hudi.
+
+<VideoList />
+
diff --git a/website/releases/release-1.0.0-beta1.md b/website/releases/release-1.0.0-beta1.md
index a4643f9e9a39..e439af58379a 100644
--- a/website/releases/release-1.0.0-beta1.md
+++ b/website/releases/release-1.0.0-beta1.md
@@ -30,7 +30,7 @@ rolling upgrades from older versions to this release.
### Format changes
[HUDI-6242](https://issues.apache.org/jira/browse/HUDI-6242) is the main epic covering all the format changes proposals,
-which are also partly covered in the [Hudi 1.0 tech specification](/tech-specs-1point0). The following are the main
+which are also partly covered in the [Hudi 1.0 tech specification](/learn/tech-specs-1point0). The following are the main
changes in this release:
#### Timeline
@@ -50,7 +50,7 @@ changes in this release:
#### Log File Format
- In addition to the fields in the log file header, we also store record positions. Refer to the
- latest [spec](/tech-specs-1point0#log-format) for more details. This allows us to do
+ latest [spec](/learn/tech-specs-1point0#log-format) for more details. This allows us to do
position-based merging (apart from key-based merging) and skip pages based on positions.
- Log file name will now have the deltacommit instant time instead of base commit instant time.
diff --git a/website/releases/release-1.0.0-beta2.md b/website/releases/release-1.0.0-beta2.md
index 6f8e9154a0a5..9ef22bf11b8b 100644
--- a/website/releases/release-1.0.0-beta2.md
+++ b/website/releases/release-1.0.0-beta2.md
@@ -29,7 +29,7 @@ rolling upgrades from older versions to this release.
### Format changes
[HUDI-6242](https://issues.apache.org/jira/browse/HUDI-6242) is the main epic covering all the format changes proposals,
-which are also partly covered in the [Hudi 1.0 tech specification](/tech-specs-1point0). The following are the main
+which are also partly covered in the [Hudi 1.0 tech specification](/learn/tech-specs-1point0). The following are the main
changes in this release:
#### Timeline
diff --git a/website/releases/release-1.0.0.md b/website/releases/release-1.0.0.md
index 7f7d7ec880f6..9a16aa5c112f 100644
--- a/website/releases/release-1.0.0.md
+++ b/website/releases/release-1.0.0.md
@@ -43,7 +43,7 @@ and [RFC-78](https://github.com/apache/hudi/blob/master/rfc/rfc-78/rfc-78.md#sup
### Format changes
The main epic covering all the format changes is [HUDI-6242](https://issues.apache.org/jira/browse/HUDI-6242), which is also
-covered in the [Hudi 1.0 tech specification](/tech-specs-1point0). The following are the main highlights with respect to format changes:
+covered in the [Hudi 1.0 tech specification](/learn/tech-specs-1point0). The following are the main highlights with respect to format changes:
#### Timeline
@@ -61,7 +61,7 @@ covered in the [Hudi 1.0 tech specification](/tech-specs-1point0). The following
#### Log File Format
- In addition to the keys in the log file header, we also store record positions. Refer to the
- latest [spec](/tech-specs-1point0#log-format) for more details. This allows us to do position-based merging (apart
+ latest [spec](/learn/tech-specs-1point0#log-format) for more details. This allows us to do position-based merging (apart
from key-based merging) and skip pages based on positions.
- Log file name will now have the deltacommit instant time instead of base commit instant time.
- The new log file format also enables fast partial updates with low storage overhead.
@@ -123,7 +123,7 @@ To learn more about partial updates, refer to the [SQL DML](/docs/sql_dml#merge-
format to another, e.g. from ORC to Parquet, without rewriting the whole table.
- **Configuration:** Enable with `hoodie.table.multiple.base.file.formats.enable`.
-To learn more about the format changes, refer to the [Hudi 1.0 tech specification](/tech-specs-1point0).
+To learn more about the format changes, refer to the [Hudi 1.0 tech specification](/learn/tech-specs-1point0).
### API Changes
diff --git a/website/sidebarsLearn.js b/website/sidebarsLearn.js
new file mode 100644
index 000000000000..f53921de3977
--- /dev/null
+++ b/website/sidebarsLearn.js
@@ -0,0 +1,51 @@
+/**
+ * Creating a sidebar enables you to:
+ - create an ordered group of docs
+ - render a sidebar for each doc of that group
+ - provide next/previous navigation
+
+ The sidebars can be generated from the filesystem, or explicitly defined here.
+
+ Create as many sidebars as you want.
+ */
+
+module.exports = {
+ learn: [
+ {
+ type: 'doc',
+ id: 'tutorial-series',
+ label: 'Tutorial Series',
+ },
+ {
+ type: 'doc',
+ id: 'blog',
+ label: 'Blogs',
+ },
+ {
+ type: 'doc',
+ id: 'talks',
+ label: 'Talks',
+ },
+ {
+ type: 'doc',
+ id: 'videos',
+ label: 'Video Guides',
+ },
+ {
+ type: 'doc',
+ id: 'faq',
+ label: 'FAQ',
+ },
+ {
+ type: 'doc',
+ id: 'tech-specs',
+ label: 'Tech Specs',
+ },
+ {
+ type: 'doc',
+ id: 'tech-specs-1point0',
+ label: 'Tech Specs 1.0',
+ },
+ ],
+};
+
diff --git a/website/src/components/BlogList/index.js b/website/src/components/BlogList/index.js
new file mode 100644
index 000000000000..86f4eea484bc
--- /dev/null
+++ b/website/src/components/BlogList/index.js
@@ -0,0 +1,164 @@
+import React, { useState } from 'react';
+import Link from '@docusaurus/Link';
+import { useBaseUrlUtils } from '@docusaurus/core/lib/client/exports/useBaseUrl';
+import AuthorName from '@site/src/components/AuthorName';
+import styles from '../ContentList/styles.module.css';
+
+const allBlogPosts = ((ctx) => {
+ const blogpostNames = ctx.keys();
+ return blogpostNames.reduce(
+ (blogposts, blogpostName, i) => {
+ try {
+ const module = ctx(blogpostName);
+ if (module && (module.frontMatter || module.metadata)) {
+ return [
+ ...blogposts,
+ {
+ frontMatter: {...(module.frontMatter || {})},
+ metadata: {...(module.metadata || {})},
+ assets: {...(module.assets || {})}
+ },
+ ];
+ }
+ } catch (e) {
+ console.warn('Error loading blog post:', blogpostName, e);
+ }
+ return blogposts;
+ },
+ []
+ );
+})(require.context('../../../blog', true, /\.mdx?$/));
+
+const sortedBlogPosts = allBlogPosts
+ .filter(post => post.metadata && post.metadata.title && post.metadata.permalink)
+ .sort((a,b) => {
+ const dateA = a.metadata?.date ? new Date(a.metadata.date).getTime() : 0;
+ const dateB = b.metadata?.date ? new Date(b.metadata.date).getTime() : 0;
+ return dateB - dateA;
+ });
+
+const POSTS_PER_PAGE = 10;
+
+export default function BlogList() {
+ const { withBaseUrl } = useBaseUrlUtils();
+ const [currentPage, setCurrentPage] = useState(1);
+
+ const totalPages = Math.ceil(sortedBlogPosts.length / POSTS_PER_PAGE);
+ const startIndex = (currentPage - 1) * POSTS_PER_PAGE;
+ const endIndex = startIndex + POSTS_PER_PAGE;
+ const currentPosts = sortedBlogPosts.slice(startIndex, endIndex);
+
+ const handlePageChange = (page) => {
+ setCurrentPage(page);
+ window.scrollTo({ top: 0, behavior: 'smooth' });
+ };
+
+ const getPageNumbers = () => {
+ const pages = [];
+ const maxVisible = 5;
+ let startPage = Math.max(1, currentPage - Math.floor(maxVisible / 2));
+ let endPage = Math.min(totalPages, startPage + maxVisible - 1);
+
+ if (endPage - startPage < maxVisible - 1) {
+ startPage = Math.max(1, endPage - maxVisible + 1);
+ }
+
+ for (let i = startPage; i <= endPage; i++) {
+ pages.push(i);
+ }
+ return pages;
+ };
+
+ return (
+ <div className={styles.container}>
+ <h2>All Blog Posts</h2>
+ <div className={styles.grid}>
+ {currentPosts.map((blog, index) => {
+ const { frontMatter, assets, metadata } = blog;
+ const { date, title, authors, permalink, description } = metadata || {};
+ const image = assets?.image ?? frontMatter?.image ?? "/assets/images/hudi.png";
+
+ if (!title || !permalink) {
+ return null;
+ }
+
+ const dateObj = date ? new Date(date) : null;
+ const formattedDate = dateObj ? dateObj.toLocaleDateString('en-US', {
+ year: 'numeric',
+ month: 'long',
+ day: 'numeric'
+ }) : '';
+
+ return (
+ <article key={index} className={styles.card}>
+ <Link to={permalink} className={styles.link} target="_blank" rel="noopener noreferrer">
+ <div className={styles.imageWrapper}>
+ <img
+ src={withBaseUrl(image, { absolute: true })}
+ alt={title}
+ className={styles.image}
+ />
+ </div>
+ <div className={styles.content}>
+ <div className={styles.meta}>
+ <AuthorName
+ authors={authors}
+ className={styles.authorName}
+ withLink={false}
+ />
+ <span className={styles.date}>{formattedDate}</span>
+ </div>
+ <h3 className={styles.title}>{title}</h3>
+ {description && (
+ <p className={styles.description}>{description}</p>
+ )}
+ </div>
+ </Link>
+ </article>
+ );
+ })}
+ </div>
+
+ {totalPages > 1 && (
+ <nav className={styles.pagination} aria-label="Blog pagination">
+ <button
+ className={styles.paginationButton}
+ onClick={() => handlePageChange(currentPage - 1)}
+ disabled={currentPage === 1}
+ aria-label="Previous page"
+ >
+ Previous
+ </button>
+
+ <div className={styles.paginationNumbers}>
+ {getPageNumbers().map((pageNum) => (
+ <button
+ key={pageNum}
+ className={`${styles.paginationNumber} ${currentPage === pageNum ? styles.active : ''}`}
+ onClick={() => handlePageChange(pageNum)}
+ aria-label={`Page ${pageNum}`}
+ aria-current={currentPage === pageNum ? 'page' : undefined}
+ >
+ {pageNum}
+ </button>
+ ))}
+ </div>
+
+ <button
+ className={styles.paginationButton}
+ onClick={() => handlePageChange(currentPage + 1)}
+ disabled={currentPage === totalPages}
+ aria-label="Next page"
+ >
+ Next
+ </button>
+ </nav>
+ )}
+
+ <div className={styles.paginationInfo}>
+ Showing {startIndex + 1}-{Math.min(endIndex, sortedBlogPosts.length)} of {sortedBlogPosts.length} posts
+ </div>
+ </div>
+ );
+}
+
diff --git a/website/src/components/ContentList/styles.module.css b/website/src/components/ContentList/styles.module.css
new file mode 100644
index 000000000000..fa1caa1210d6
--- /dev/null
+++ b/website/src/components/ContentList/styles.module.css
@@ -0,0 +1,199 @@
+/* Shared styles for BlogList, VideoList, and FAQList */
+
+.container {
+ margin-top: 2rem;
+}
+
+.container h2 {
+ margin-bottom: 2rem;
+ font-size: 2rem;
+}
+
+.grid {
+ display: grid;
+ grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+ gap: 2rem;
+}
+
+.card {
+ border: 1px solid var(--ifm-color-emphasis-200);
+ border-radius: 8px;
+ overflow: hidden;
+ transition: transform 0.2s, box-shadow 0.2s;
+}
+
+.card:hover {
+ transform: translateY(-4px);
+ box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+}
+
+.link {
+ display: block;
+ text-decoration: none;
+ color: inherit;
+}
+
+.imageWrapper {
+ width: 100%;
+ height: 200px;
+ overflow: hidden;
+ background-color: var(--ifm-color-emphasis-100);
+}
+
+.image {
+ width: 100%;
+ height: 100%;
+ object-fit: cover;
+}
+
+.content {
+ padding: 1.5rem;
+}
+
+.meta {
+ display: flex;
+ align-items: center;
+ gap: 1rem;
+ margin-bottom: 0.75rem;
+ font-size: 0.875rem;
+ color: var(--ifm-color-emphasis-600);
+}
+
+.date {
+ font-size: 0.875rem;
+}
+
+.title {
+ font-size: 1.25rem;
+ font-weight: 600;
+ margin: 0.5rem 0;
+ color: var(--ifm-heading-color);
+}
+
+.description {
+ font-size: 0.9375rem;
+ color: var(--ifm-color-emphasis-700);
+ line-height: 1.5;
+ margin-top: 0.5rem;
+ display: -webkit-box;
+ -webkit-line-clamp: 3;
+ line-clamp: 3;
+ -webkit-box-orient: vertical;
+ overflow: hidden;
+}
+
+/* Pagination styles */
+.pagination {
+ display: flex;
+ justify-content: center;
+ align-items: center;
+ gap: 1rem;
+ margin-top: 3rem;
+ padding: 2rem 0;
+}
+
+.paginationButton {
+ padding: 0.5rem 1rem;
+ border: 1px solid var(--ifm-color-emphasis-300);
+ border-radius: 4px;
+ background-color: var(--ifm-background-color);
+ color: var(--ifm-font-color-base);
+ cursor: pointer;
+ font-size: 0.9375rem;
+ transition: background-color 0.2s, border-color 0.2s;
+}
+
+.paginationButton:hover:not(:disabled) {
+ background-color: var(--ifm-color-emphasis-100);
+ border-color: var(--ifm-color-primary);
+}
+
+.paginationButton:disabled {
+ opacity: 0.5;
+ cursor: not-allowed;
+}
+
+.paginationNumbers {
+ display: flex;
+ gap: 0.5rem;
+}
+
+.paginationNumber {
+ min-width: 2.5rem;
+ height: 2.5rem;
+ padding: 0.5rem;
+ border: 1px solid var(--ifm-color-emphasis-300);
+ border-radius: 4px;
+ background-color: var(--ifm-background-color);
+ color: var(--ifm-font-color-base);
+ cursor: pointer;
+ font-size: 0.9375rem;
+ transition: background-color 0.2s, border-color 0.2s, color 0.2s;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+}
+
+.paginationNumber:hover {
+ background-color: var(--ifm-color-emphasis-100);
+ border-color: var(--ifm-color-primary);
+}
+
+.paginationNumber.active {
+ background-color: var(--ifm-color-primary);
+ border-color: var(--ifm-color-primary);
+ color: var(--ifm-color-primary-contrast-background);
+}
+
+.paginationInfo {
+ text-align: center;
+ margin-top: 1rem;
+ color: var(--ifm-color-emphasis-600);
+ font-size: 0.875rem;
+}
+
+/* Component-specific styles */
+
+/* Author name (used by BlogList and VideoList) */
+.authorName {
+ font-size: 0.875rem;
+}
+
+/* FAQ-specific styles */
+.faqCard {
+ background-color: var(--ifm-background-color);
+}
+
+.faqCard:hover {
+ border-color: var(--ifm-color-primary);
+}
+
+.faqLink {
+ height: 100%;
+}
+
+.faqContent {
+ display: flex;
+ flex-direction: column;
+ height: 100%;
+}
+
+.faqDescription {
+ margin: 0 0 1rem 0;
+ flex-grow: 1;
+}
+
+.faqAction {
+ margin-top: auto;
+}
+
+.faqLinkText {
+ font-size: 0.9375rem;
+ color: var(--ifm-color-primary);
+ font-weight: 500;
+}
+
+.faqCard:hover .faqLinkText {
+ text-decoration: underline;
+}
+
diff --git a/website/src/components/FAQList/index.js b/website/src/components/FAQList/index.js
new file mode 100644
index 000000000000..dbe7b1c59ad9
--- /dev/null
+++ b/website/src/components/FAQList/index.js
@@ -0,0 +1,72 @@
+import React from 'react';
+import Link from '@docusaurus/Link';
+import styles from '../ContentList/styles.module.css';
+
+const faqSections = [
+ {
+ id: 'general',
+ title: 'General FAQ',
+ description: 'General questions about Hudi, use cases, and getting started.',
+ href: '/faq/general',
+ },
+ {
+ id: 'design_and_concepts',
+ title: 'Design & Concepts',
+ description: 'Questions about Hudi\'s design, architecture, and core concepts.',
+ href: '/faq/design_and_concepts',
+ },
+ {
+ id: 'writing_tables',
+ title: 'Writing Tables',
+ description: 'Questions about writing data to Hudi tables, upserts, and inserts.',
+ href: '/faq/writing_tables',
+ },
+ {
+ id: 'reading_tables',
+ title: 'Reading Tables',
+ description: 'Questions about reading data from Hudi tables and query types.',
+ href: '/faq/reading_tables',
+ },
+ {
+ id: 'table_services',
+ title: 'Table Services',
+ description: 'Questions about compaction, cleaning, clustering, and other table services.',
+ href: '/faq/table_services',
+ },
+ {
+ id: 'storage',
+ title: 'Storage',
+ description: 'Questions about Hudi storage formats, file layouts, and data organization.',
+ href: '/faq/storage',
+ },
+ {
+ id: 'integrations',
+ title: 'Integrations',
+ description: 'Questions about integrating Hudi with Spark, Flink, Presto, and other systems.',
+ href: '/faq/integrations',
+ },
+];
+
+export default function FAQList() {
+ return (
+ <div className={styles.container}>
+ <h2>FAQ Sections</h2>
+ <div className={styles.grid}>
+ {faqSections.map((section) => (
+ <article key={section.id} className={`${styles.card} ${styles.faqCard}`}>
+ <Link to={section.href} className={`${styles.link} ${styles.faqLink}`} target="_blank" rel="noopener noreferrer">
+ <div className={`${styles.content} ${styles.faqContent}`}>
+ <h3 className={styles.title}>{section.title}</h3>
+ <p className={`${styles.description} ${styles.faqDescription}`}>{section.description}</p>
+ <div className={styles.faqAction}>
+ <span className={styles.faqLinkText}>Read more →</span>
+ </div>
+ </div>
+ </Link>
+ </article>
+ ))}
+ </div>
+ </div>
+ );
+}
+
diff --git a/website/src/components/VideoList/index.js b/website/src/components/VideoList/index.js
new file mode 100644
index 000000000000..361f8645692c
--- /dev/null
+++ b/website/src/components/VideoList/index.js
@@ -0,0 +1,173 @@
+import React, { useState } from 'react';
+import Link from '@docusaurus/Link';
+import { useBaseUrlUtils } from '@docusaurus/core/lib/client/exports/useBaseUrl';
+import AuthorName from '@site/src/components/AuthorName';
+import styles from '../ContentList/styles.module.css';
+
+const allVideos = ((ctx) => {
+ const videoNames = ctx.keys();
+ return videoNames.reduce(
+ (videos, videoName, i) => {
+ try {
+ const module = ctx(videoName);
+ if (module && (module.frontMatter || module.metadata)) {
+ return [
+ ...videos,
+ {
+ frontMatter: {...(module.frontMatter || {})},
+ metadata: {...(module.metadata || {})},
+ assets: {...(module.assets || {})}
+ },
+ ];
+ }
+ } catch (e) {
+ console.warn('Error loading video:', videoName, e);
+ }
+ return videos;
+ },
+ []
+ );
+})(require.context('../../../videoBlog', true, /\.mdx?$/));
+
+const sortedVideos = allVideos
+ .filter(video => video.metadata && video.metadata.title && video.metadata.permalink)
+ .sort((a,b) => {
+ const dateA = a.metadata?.date ? new Date(a.metadata.date).getTime() : 0;
+ const dateB = b.metadata?.date ? new Date(b.metadata.date).getTime() : 0;
+ return dateB - dateA;
+ });
+
+const POSTS_PER_PAGE = 10;
+
+export default function VideoList() {
+ const { withBaseUrl } = useBaseUrlUtils();
+ const [currentPage, setCurrentPage] = useState(1);
+
+ const totalPages = Math.ceil(sortedVideos.length / POSTS_PER_PAGE);
+ const startIndex = (currentPage - 1) * POSTS_PER_PAGE;
+ const endIndex = startIndex + POSTS_PER_PAGE;
+ const currentVideos = sortedVideos.slice(startIndex, endIndex);
+
+ const handlePageChange = (page) => {
+ setCurrentPage(page);
+ window.scrollTo({ top: 0, behavior: 'smooth' });
+ };
+
+ const getPageNumbers = () => {
+ const pages = [];
+ const maxVisible = 5;
+ let startPage = Math.max(1, currentPage - Math.floor(maxVisible / 2));
+ let endPage = Math.min(totalPages, startPage + maxVisible - 1);
+
+ if (endPage - startPage < maxVisible - 1) {
+ startPage = Math.max(1, endPage - maxVisible + 1);
+ }
+
+ for (let i = startPage; i <= endPage; i++) {
+ pages.push(i);
+ }
+ return pages;
+ };
+
+ return (
+ <div className={styles.container}>
+ <h2>All Video Guides</h2>
+ <div className={styles.grid}>
+ {currentVideos.map((video, index) => {
+ const { frontMatter, assets, metadata } = video;
+ const { date, title, authors, permalink, description } = metadata || {};
+ const image = assets?.image ?? frontMatter?.image ?? "/assets/images/hudi.png";
+ const videoUrl = frontMatter?.navigate || permalink;
+
+ if (!title || !videoUrl) {
+ return null;
+ }
+
+ const dateObj = date ? new Date(date) : null;
+ const formattedDate = dateObj ? dateObj.toLocaleDateString('en-US', {
+ year: 'numeric',
+ month: 'long',
+ day: 'numeric'
+ }) : '';
+
+ const isExternalUrl = videoUrl && (videoUrl.startsWith('http://') || videoUrl.startsWith('https://'));
+ const LinkComponent = isExternalUrl ? 'a' : Link;
+ const linkProps = isExternalUrl
+ ? { href: videoUrl, target: '_blank', rel: 'noopener noreferrer' }
+ : { to: videoUrl, target: '_blank', rel: 'noopener noreferrer' };
+
+ return (
+ <article key={index} className={styles.card}>
+ <LinkComponent {...linkProps} className={styles.link}>
+ <div className={styles.imageWrapper}>
+ <img
+ src={withBaseUrl(image, { absolute: true })}
+ alt={title}
+ className={styles.image}
+ />
+ </div>
+ <div className={styles.content}>
+ <div className={styles.meta}>
+ {authors && authors.length > 0 && (
+ <AuthorName
+ authors={authors}
+ className={styles.authorName}
+ withLink={false}
+ />
+ )}
+ <span className={styles.date}>{formattedDate}</span>
+ </div>
+ <h3 className={styles.title}>{title}</h3>
+ {description && (
+ <p className={styles.description}>{description}</p>
+ )}
+ </div>
+ </LinkComponent>
+ </article>
+ );
+ })}
+ </div>
+
+ {totalPages > 1 && (
+ <nav className={styles.pagination} aria-label="Video pagination">
+ <button
+ className={styles.paginationButton}
+ onClick={() => handlePageChange(currentPage - 1)}
+ disabled={currentPage === 1}
+ aria-label="Previous page"
+ >
+ Previous
+ </button>
+
+ <div className={styles.paginationNumbers}>
+ {getPageNumbers().map((pageNum) => (
+ <button
+ key={pageNum}
+ className={`${styles.paginationNumber} ${currentPage === pageNum ? styles.active : ''}`}
+ onClick={() => handlePageChange(pageNum)}
+ aria-label={`Page ${pageNum}`}
+ aria-current={currentPage === pageNum ? 'page' : undefined}
+ >
+ {pageNum}
+ </button>
+ ))}
+ </div>
+
+ <button
+ className={styles.paginationButton}
+ onClick={() => handlePageChange(currentPage + 1)}
+ disabled={currentPage === totalPages}
+ aria-label="Next page"
+ >
+ Next
+ </button>
+ </nav>
+ )}
+
+ <div className={styles.paginationInfo}>
+ Showing {startIndex + 1}-{Math.min(endIndex, sortedVideos.length)} of {sortedVideos.length} videos
+ </div>
+ </div>
+ );
+}
+
diff --git a/website/src/pages/faq.md b/website/src/pages/faq.md
deleted file mode 100644
index c14eaf650c36..000000000000
--- a/website/src/pages/faq.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: FAQ Overview
-keywords: [hudi, writing, reading]
----
-
-# FAQ Overview
-
-The FAQs are split into following pages. Please refer to the specific pages for more info.
-
-- [General](faq/general)
-- [Design & Concepts](faq/design_and_concepts)
-- [Writing Tables](faq/writing_tables)
-- [Reading Tables](faq/reading_tables)
-- [Table Services](faq/table_services)
-- [Storage](faq/storage)
-- [Integrations](faq/integrations)
diff --git a/website/src/pages/faq/design_and_concepts.md b/website/src/pages/faq/design_and_concepts.md
index f21c553ec3af..11c6e7040c09 100644
--- a/website/src/pages/faq/design_and_concepts.md
+++ b/website/src/pages/faq/design_and_concepts.md
@@ -13,7 +13,7 @@ Hudi writers atomically move an inflight write operation to a "completed" state
Hudi is very different from Hive in important aspects described below. However, based on practical considerations, it chooses to be compatible with Hive table layout by adopting partitioning, schema evolution and being queryable through Hive query engine. Here are the key aspect where Hudi differs:
-* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](/docs/use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
+* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/learn/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](/docs/use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
* Hive advocates partitioning as the main remedy for most performance-based issues. Features like partition evolution and hidden partitioning are primarily based on this Hive based principle of partitioning and aim to tackle the metadata problem partially. Whereas, Hudi biases to coarse-grained partitioning and emphasizes [clustering](/docs/clustering) for more fine-grained partitioning. Further, users can strategize and evolve the clustering asynchronously which “actually” help users [...]
* Hudi considers partition evolution as an anti-pattern and avoids such schemes due to the inconsistent performance of queries that goes to depend on which part of the table is being queried. Hudi’s design favors consistent performance and is aware of the need to redesign to partitioning/tables to achieve the same.
diff --git a/website/src/pages/faq/storage.md b/website/src/pages/faq/storage.md
index a266405a489e..66b7f8ea23d6 100644
--- a/website/src/pages/faq/storage.md
+++ b/website/src/pages/faq/storage.md
@@ -189,6 +189,6 @@ validate the properties.
Hudi was not originally designed as a database layer that would fit under the various big data query engines, that were painfully hard to integrate with (Spark did not have DataSet/DataSource APIs, Trino was still Presto, Presto SPI was still budding, Hive storage handlers were just out). Popular engines including Spark, Flink, Presto, Trino, and Athena do not have issues integrating with Hudi as they are all based on JVM, and access access to Timeline, Metadata table are well-abstracted [...]
-Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
+Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
**_Note_**: _In a recent release the delete block keys were unintentionally serialized as kryo, and is being fixed in the 0.14 release. Thankfully, since Hudi’s log blocks and format are versioned, when the file slice is compacted things return to normal._
diff --git a/website/versioned_docs/version-0.14.0/faq.md b/website/versioned_docs/version-0.14.0/faq.md
index 2f0c4c5fd7b3..ef31aab3d1c5 100644
--- a/website/versioned_docs/version-0.14.0/faq.md
+++ b/website/versioned_docs/version-0.14.0/faq.md
@@ -110,7 +110,7 @@ Hudi writers atomically move an inflight write operation to a "completed" state
Hudi is very different from Hive in important aspects described below. However, based on practical considerations, it chooses to be compatible with Hive table layout by adopting partitioning, schema evolution and being queryable through Hive query engine. Here are the key aspect where Hudi differs:
-* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](https://hudi.apache.org/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hi [...]
+* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](https://hudi.apache.org/learn/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond sim [...]
* Hive advocates partitioning as the main remedy for most performance-based issues. Features like partition evolution and hidden partitioning are primarily based on this Hive based principle of partitioning and aim to tackle the metadata problem partially. Whereas, Hudi biases to coarse-grained partitioning and emphasizes [clustering](https://hudi.apache.org/docs/clustering) for more fine-grained partitioning. Further, users can strategize and evolve the clustering asynchronously whic [...]
* Hudi considers partition evolution as an anti-pattern and avoids such schemes due to the inconsistent performance of queries that goes to depend on which part of the table is being queried. Hudi’s design favors consistent performance and is aware of the need to redesign to partitioning/tables to achieve the same.
diff --git a/website/versioned_docs/version-0.14.1/faq_design_and_concepts.md b/website/versioned_docs/version-0.14.1/faq_design_and_concepts.md
index 3f6a7faba1b1..720f4ae8e2df 100644
--- a/website/versioned_docs/version-0.14.1/faq_design_and_concepts.md
+++ b/website/versioned_docs/version-0.14.1/faq_design_and_concepts.md
@@ -12,7 +12,7 @@ Hudi writers atomically move an inflight write operation to a "completed" state
Hudi is very different from Hive in important aspects described below. However, based on practical considerations, it chooses to be compatible with Hive table layout by adopting partitioning, schema evolution and being queryable through Hive query engine. Here are the key aspect where Hudi differs:
-* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
+* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/learn/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
* Hive advocates partitioning as the main remedy for most performance-based issues. Features like partition evolution and hidden partitioning are primarily based on this Hive based principle of partitioning and aim to tackle the metadata problem partially. Whereas, Hudi biases to coarse-grained partitioning and emphasizes [clustering](clustering) for more fine-grained partitioning. Further, users can strategize and evolve the clustering asynchronously which “actually” help users exper [...]
* Hudi considers partition evolution as an anti-pattern and avoids such schemes due to the inconsistent performance of queries that goes to depend on which part of the table is being queried. Hudi’s design favors consistent performance and is aware of the need to redesign to partitioning/tables to achieve the same.
diff --git a/website/versioned_docs/version-0.14.1/faq_storage.md b/website/versioned_docs/version-0.14.1/faq_storage.md
index 9afb6456b774..5b554b738098 100644
--- a/website/versioned_docs/version-0.14.1/faq_storage.md
+++ b/website/versioned_docs/version-0.14.1/faq_storage.md
@@ -188,6 +188,6 @@ validate the properties.
Hudi was not originally designed as a database layer that would fit under the various big data query engines, that were painfully hard to integrate with (Spark did not have DataSet/DataSource APIs, Trino was still Presto, Presto SPI was still budding, Hive storage handlers were just out). Popular engines including Spark, Flink, Presto, Trino, and Athena do not have issues integrating with Hudi as they are all based on JVM, and access access to Timeline, Metadata table are well-abstracted [...]
-Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
+Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
**_Note_**: _In a recent release the delete block keys were unintentionally serialized as kryo, and is being fixed in the 0.14 release. Thankfully, since Hudi’s log blocks and format are versioned, when the file slice is compacted things return to normal._
diff --git a/website/versioned_docs/version-0.15.0/faq_design_and_concepts.md b/website/versioned_docs/version-0.15.0/faq_design_and_concepts.md
index 3f6a7faba1b1..720f4ae8e2df 100644
--- a/website/versioned_docs/version-0.15.0/faq_design_and_concepts.md
+++ b/website/versioned_docs/version-0.15.0/faq_design_and_concepts.md
@@ -12,7 +12,7 @@ Hudi writers atomically move an inflight write operation to a "completed" state
Hudi is very different from Hive in important aspects described below. However, based on practical considerations, it chooses to be compatible with Hive table layout by adopting partitioning, schema evolution and being queryable through Hive query engine. Here are the key aspect where Hudi differs:
-* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
+* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/learn/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
* Hive advocates partitioning as the main remedy for most performance-based issues. Features like partition evolution and hidden partitioning are primarily based on this Hive based principle of partitioning and aim to tackle the metadata problem partially. Whereas, Hudi biases to coarse-grained partitioning and emphasizes [clustering](clustering) for more fine-grained partitioning. Further, users can strategize and evolve the clustering asynchronously which “actually” help users exper [...]
* Hudi considers partition evolution as an anti-pattern and avoids such schemes due to the inconsistent performance of queries that goes to depend on which part of the table is being queried. Hudi’s design favors consistent performance and is aware of the need to redesign to partitioning/tables to achieve the same.
diff --git a/website/versioned_docs/version-0.15.0/faq_storage.md b/website/versioned_docs/version-0.15.0/faq_storage.md
index 754a678c9396..27fe9ed70ffd 100644
--- a/website/versioned_docs/version-0.15.0/faq_storage.md
+++ b/website/versioned_docs/version-0.15.0/faq_storage.md
@@ -202,6 +202,6 @@ mvn clean install -Denforcer.skip -DskipTests -Dhadoop.profile=3.0 -Psite-instal
Hudi was not originally designed as a database layer that would fit under the various big data query engines, that were painfully hard to integrate with (Spark did not have DataSet/DataSource APIs, Trino was still Presto, Presto SPI was still budding, Hive storage handlers were just out). Popular engines including Spark, Flink, Presto, Trino, and Athena do not have issues integrating with Hudi as they are all based on JVM, and access access to Timeline, Metadata table are well-abstracted [...]
-Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
+Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
**_Note_**: _In a recent release the delete block keys were unintentionally serialized as kryo, and is being fixed in the 0.14 release. Thankfully, since Hudi’s log blocks and format are versioned, when the file slice is compacted things return to normal._
diff --git a/website/versioned_docs/version-1.0.0/faq_design_and_concepts.md b/website/versioned_docs/version-1.0.0/faq_design_and_concepts.md
index 3f6a7faba1b1..720f4ae8e2df 100644
--- a/website/versioned_docs/version-1.0.0/faq_design_and_concepts.md
+++ b/website/versioned_docs/version-1.0.0/faq_design_and_concepts.md
@@ -12,7 +12,7 @@ Hudi writers atomically move an inflight write operation to a "completed" state
Hudi is very different from Hive in important aspects described below. However, based on practical considerations, it chooses to be compatible with Hive table layout by adopting partitioning, schema evolution and being queryable through Hive query engine. Here are the key aspect where Hudi differs:
-* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
+* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/learn/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
* Hive advocates partitioning as the main remedy for most performance-based issues. Features like partition evolution and hidden partitioning are primarily based on this Hive based principle of partitioning and aim to tackle the metadata problem partially. Whereas, Hudi biases to coarse-grained partitioning and emphasizes [clustering](clustering) for more fine-grained partitioning. Further, users can strategize and evolve the clustering asynchronously which “actually” help users exper [...]
* Hudi considers partition evolution as an anti-pattern and avoids such schemes due to the inconsistent performance of queries that goes to depend on which part of the table is being queried. Hudi’s design favors consistent performance and is aware of the need to redesign to partitioning/tables to achieve the same.
diff --git a/website/versioned_docs/version-1.0.0/faq_storage.md b/website/versioned_docs/version-1.0.0/faq_storage.md
index 708ae6181750..b088b30d8ebd 100644
--- a/website/versioned_docs/version-1.0.0/faq_storage.md
+++ b/website/versioned_docs/version-1.0.0/faq_storage.md
@@ -188,6 +188,6 @@ validate the properties.
Hudi was not originally designed as a database layer that would fit under the various big data query engines, that were painfully hard to integrate with (Spark did not have DataSet/DataSource APIs, Trino was still Presto, Presto SPI was still budding, Hive storage handlers were just out). Popular engines including Spark, Flink, Presto, Trino, and Athena do not have issues integrating with Hudi as they are all based on JVM, and access access to Timeline, Metadata table are well-abstracted [...]
-Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
+Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
**_Note_**: _In a recent release the delete block keys were unintentionally serialized as kryo, and is being fixed in the 0.14 release. Thankfully, since Hudi’s log blocks and format are versioned, when the file slice is compacted things return to normal._
diff --git a/website/versioned_docs/version-1.0.1/faq_design_and_concepts.md b/website/versioned_docs/version-1.0.1/faq_design_and_concepts.md
index 3f6a7faba1b1..720f4ae8e2df 100644
--- a/website/versioned_docs/version-1.0.1/faq_design_and_concepts.md
+++ b/website/versioned_docs/version-1.0.1/faq_design_and_concepts.md
@@ -12,7 +12,7 @@ Hudi writers atomically move an inflight write operation to a "completed" state
Hudi is very different from Hive in important aspects described below. However, based on practical considerations, it chooses to be compatible with Hive table layout by adopting partitioning, schema evolution and being queryable through Hive query engine. Here are the key aspect where Hudi differs:
-* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
+* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/learn/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
* Hive advocates partitioning as the main remedy for most performance-based issues. Features like partition evolution and hidden partitioning are primarily based on this Hive based principle of partitioning and aim to tackle the metadata problem partially. Whereas, Hudi biases to coarse-grained partitioning and emphasizes [clustering](clustering) for more fine-grained partitioning. Further, users can strategize and evolve the clustering asynchronously which “actually” help users exper [...]
* Hudi considers partition evolution as an anti-pattern and avoids such schemes due to the inconsistent performance of queries that goes to depend on which part of the table is being queried. Hudi’s design favors consistent performance and is aware of the need to redesign to partitioning/tables to achieve the same.
diff --git a/website/versioned_docs/version-1.0.1/faq_storage.md b/website/versioned_docs/version-1.0.1/faq_storage.md
index 708ae6181750..b088b30d8ebd 100644
--- a/website/versioned_docs/version-1.0.1/faq_storage.md
+++ b/website/versioned_docs/version-1.0.1/faq_storage.md
@@ -188,6 +188,6 @@ validate the properties.
Hudi was not originally designed as a database layer that would fit under the various big data query engines, that were painfully hard to integrate with (Spark did not have DataSet/DataSource APIs, Trino was still Presto, Presto SPI was still budding, Hive storage handlers were just out). Popular engines including Spark, Flink, Presto, Trino, and Athena do not have issues integrating with Hudi as they are all based on JVM, and access access to Timeline, Metadata table are well-abstracted [...]
-Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
+Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
**_Note_**: _In a recent release the delete block keys were unintentionally serialized as kryo, and is being fixed in the 0.14 release. Thankfully, since Hudi’s log blocks and format are versioned, when the file slice is compacted things return to normal._
diff --git a/website/versioned_docs/version-1.0.2/faq_design_and_concepts.md b/website/versioned_docs/version-1.0.2/faq_design_and_concepts.md
index 3f6a7faba1b1..720f4ae8e2df 100644
--- a/website/versioned_docs/version-1.0.2/faq_design_and_concepts.md
+++ b/website/versioned_docs/version-1.0.2/faq_design_and_concepts.md
@@ -12,7 +12,7 @@ Hudi writers atomically move an inflight write operation to a "completed" state
Hudi is very different from Hive in important aspects described below. However, based on practical considerations, it chooses to be compatible with Hive table layout by adopting partitioning, schema evolution and being queryable through Hive query engine. Here are the key aspect where Hudi differs:
-* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
+* Unlike Hive, Hudi does not remove the partition columns from the data files. Hudi in fact adds record level [meta fields](/learn/tech-specs#meta-fields) including instant time, primary record key, and partition path to the data to support efficient upserts and [incremental queries/ETL](use_cases#efficient-data-lakes-with-incremental-processing). Hudi tables can be non-partitioned and the Hudi metadata table adds rich indexes on Hudi tables which are beyond simple Hive extensions.
* Hive advocates partitioning as the main remedy for most performance-based issues. Features like partition evolution and hidden partitioning are primarily based on this Hive based principle of partitioning and aim to tackle the metadata problem partially. Whereas, Hudi biases to coarse-grained partitioning and emphasizes [clustering](clustering) for more fine-grained partitioning. Further, users can strategize and evolve the clustering asynchronously which “actually” help users exper [...]
* Hudi considers partition evolution as an anti-pattern and avoids such schemes due to the inconsistent performance of queries that goes to depend on which part of the table is being queried. Hudi’s design favors consistent performance and is aware of the need to redesign to partitioning/tables to achieve the same.
diff --git a/website/versioned_docs/version-1.0.2/faq_storage.md b/website/versioned_docs/version-1.0.2/faq_storage.md
index 708ae6181750..b088b30d8ebd 100644
--- a/website/versioned_docs/version-1.0.2/faq_storage.md
+++ b/website/versioned_docs/version-1.0.2/faq_storage.md
@@ -188,6 +188,6 @@ validate the properties.
Hudi was not originally designed as a database layer that would fit under the various big data query engines, that were painfully hard to integrate with (Spark did not have DataSet/DataSource APIs, Trino was still Presto, Presto SPI was still budding, Hive storage handlers were just out). Popular engines including Spark, Flink, Presto, Trino, and Athena do not have issues integrating with Hudi as they are all based on JVM, and access access to Timeline, Metadata table are well-abstracted [...]
-Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
+Since it was not thought of as a "format", the focus on the APIs for such lower level integrations and documenting the serialized bytes has been historically inadequate. However, with some understanding of the serialization, looking beyond the APIs used and focus on what the serialized bytes are, its possible to integrate Hudi from outside the JVM. For e.g Bloom filters are serialized as hex strings, from byte arrays/primitive types, and should be **readable cross language**. The Hudi Lo [...]
**_Note_**: _In a recent release the delete block keys were unintentionally serialized as kryo, and is being fixed in the 0.14 release. Thankfully, since Hudi’s log blocks and format are versioned, when the file slice is compacted things return to normal._