You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@doris.apache.org by mo...@apache.org on 2026/10/19 15:59:38 UTC

(doris-website) branch master updated: [i18n](ko) Translate 100 documentation pages (T09 20261019T130315Z-026) (#4394)

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 30450371114 [i18n](ko) Translate 100 documentation pages (T09 20261019T130315Z-026) (#4394)
30450371114 is described below

commit 304503711148e2666788613d1497a590b20c462f
Author: Mingyu Chen (Rayner) <mo...@gmail.com>
AuthorDate: Mon Oct 19 16:59:32 2026 +0100

    [i18n](ko) Translate 100 documentation pages (T09 20261019T130315Z-026) (#4394)
    
    Translate 100 English documentation pages into Korean with local Codex.
    
    Source: `f1464d3fb0dd6007d36104a970c3bc7db282d822`. Model:
    `gpt-6.1-sol`; reasoning effort: `xhigh`.
    These are machine translations requiring Korean proofreading. Each
    document has its own state shard.
    
    Retry summary: 28/29 generated pages passed on the first attempt; 71
    pages copied across versions; 30 total model calls. Prompt rules used:
    comments, inline-code, code-blocks, numbers, metadata, headings,
    glossary.
    
    | Source | Operation | Model calls | Result |
    | --- | --- | ---: | --- |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/LARGEINT.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/SMALLINT.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/TINYINT.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/ARRAY.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/GEO.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/JSON.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/MAP.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/STRUCT.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/VARIANT.md`
    | Translate | 2 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/variant-workload-guide.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/CHAR.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/STRING.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/VARCHAR.md`
    | Copy from current | 0 | Copied without content rechecks |
    | `versioned_docs/version-4.x/sql-manual/basic-element/variables.md` |
    Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/ai-agg.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/any-value.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/approx-count-distinct.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/array-agg.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg-map.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg-weighted.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-agg.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-intersect.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union-count.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union-int.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-and.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-or.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-xor.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/collect-list.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/collect-set.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/corr-welford.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/corr.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count-by-enum.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count-map.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/covar-samp.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/covar.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/datasketches_hll_union_agg.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-array-intersect.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-array-union.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-and.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-or.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-xor.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bitmap-xor.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-concat.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/histogram.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/hll-raw-agg.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/hll-union-agg.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/intersect-count.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/kurt.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/linear-histogram.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/map-agg.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max-by.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max-map.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/median.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min-by.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min-map.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx-array.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx-weighted.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-array.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile_reservoir.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/quantile-union.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/regr-avgx.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/regr-avgy.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/regr-count.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/regr-intercept.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/regr-r2.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/regr-slope.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/regr-sxx.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/regr-sxy.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/regr-syy.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/retention.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/sem.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/sequence-count.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/sequence-match.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/skew.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/stddev-samp.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/stddev.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/sum-map.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/sum.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/sum0.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/topn-array.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/topn-weighted.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/topn.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/var-samp.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/variance.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/aggregate-functions/window-funnel.md`
    | Translate | 1 | Local gates passed |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/ai-functions/ai-classify.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/ai-functions/ai-extract.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/ai-functions/ai-filter.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/ai-functions/ai-fixgrammar.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/ai-functions/ai-generate.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/ai-functions/ai-mask.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/ai-functions/ai-sentiment.md`
    | Copy from current | 0 | Copied without content rechecks |
    |
    `versioned_docs/version-4.x/sql-manual/sql-functions/ai-functions/ai-similarity.md`
    | Copy from current | 0 | Copied without content rechecks |
    
    Validation:
    
    - scope-ko: passed
    - configuration-ko: passed
    - state-protection-ko: passed
    - syntax-ko: passed
    - internal-links-ko: passed
    
    Local checks reuse translation state, protection, Markdown/MDX syntax
    and internal-link functions for Korean files.
    Copied pages skip content, syntax and link rechecks; only file scope,
    state identity and hashes are verified.
    Local validation does not build the website or run the CI test suites.
    GitHub CI runs independently.
    Failures are fed into the next translation prompt, with at most three
    total model attempts per page.
    The third translation is retained when local checks still fail, as
    requested; this does not waive GitHub CI.
    
    Retained warnings:
    
    None.
    
    Remaining blocking local checks: none.
    
    This batch is independent of other translation PRs. The runner continues
    without waiting for merge.
    
    <!-- korean-local-t09 source=f1464d3fb0dd6007d36104a970c3bc7db282d822
    -->
    
    Co-authored-by: morningman <mo...@apache.org>
---
 .../sql-data-types/numeric/LARGEINT.md             |   15 +
 .../sql-data-types/numeric/SMALLINT.md             |   15 +
 .../sql-data-types/numeric/TINYINT.md              |   15 +
 .../sql-data-types/semi-structured/ARRAY.md        |  330 ++++++
 .../sql-data-types/semi-structured/GEO.md          |  397 +++++++
 .../sql-data-types/semi-structured/JSON.md         | 1230 ++++++++++++++++++++
 .../sql-data-types/semi-structured/MAP.md          |  222 ++++
 .../sql-data-types/semi-structured/STRUCT.md       |  248 ++++
 .../sql-data-types/semi-structured/VARIANT.md      |  624 ++++++++++
 .../semi-structured/variant-workload-guide.md      |  315 +++++
 .../sql-data-types/string-type/CHAR.md             |   18 +
 .../sql-data-types/string-type/STRING.md           |   16 +
 .../sql-data-types/string-type/VARCHAR.md          |   17 +
 .../sql-manual/basic-element/variables.md          |  211 ++++
 .../sql-functions/aggregate-functions/ai-agg.md    |  136 +++
 .../sql-functions/aggregate-functions/any-value.md |  113 ++
 .../aggregate-functions/approx-count-distinct.md   |  136 +++
 .../sql-functions/aggregate-functions/array-agg.md |   69 ++
 .../sql-functions/aggregate-functions/avg-map.md   |  111 ++
 .../aggregate-functions/avg-weighted.md            |  108 ++
 .../sql-functions/aggregate-functions/avg.md       |  174 +++
 .../aggregate-functions/bitmap-agg.md              |  100 ++
 .../aggregate-functions/bitmap-intersect.md        |   76 ++
 .../aggregate-functions/bitmap-union-count.md      |   70 ++
 .../aggregate-functions/bitmap-union-int.md        |   69 ++
 .../aggregate-functions/bitmap-union.md            |   68 ++
 .../sql-functions/aggregate-functions/bool-and.md  |  146 +++
 .../sql-functions/aggregate-functions/bool-or.md   |  147 +++
 .../sql-functions/aggregate-functions/bool-xor.md  |  147 +++
 .../aggregate-functions/collect-list.md            |   71 ++
 .../aggregate-functions/collect-set.md             |   71 ++
 .../aggregate-functions/corr-welford.md            |  104 ++
 .../sql-functions/aggregate-functions/corr.md      |   84 ++
 .../aggregate-functions/count-by-enum.md           |  146 +++
 .../sql-functions/aggregate-functions/count-map.md |  115 ++
 .../sql-functions/aggregate-functions/count.md     |  112 ++
 .../aggregate-functions/covar-samp.md              |   76 ++
 .../sql-functions/aggregate-functions/covar.md     |   81 ++
 .../datasketches_hll_union_agg.md                  |  120 ++
 .../aggregate-functions/group-array-intersect.md   |   66 ++
 .../aggregate-functions/group-array-union.md       |   80 ++
 .../aggregate-functions/group-bit-and.md           |   68 ++
 .../aggregate-functions/group-bit-or.md            |   68 ++
 .../aggregate-functions/group-bit-xor.md           |   68 ++
 .../aggregate-functions/group-bitmap-xor.md        |   72 ++
 .../aggregate-functions/group-concat.md            |  119 ++
 .../sql-functions/aggregate-functions/histogram.md |  136 +++
 .../aggregate-functions/hll-raw-agg.md             |   74 ++
 .../aggregate-functions/hll-union-agg.md           |   69 ++
 .../aggregate-functions/intersect-count.md         |   78 ++
 .../sql-functions/aggregate-functions/kurt.md      |   81 ++
 .../aggregate-functions/linear-histogram.md        |   96 ++
 .../sql-functions/aggregate-functions/map-agg.md   |  105 ++
 .../sql-functions/aggregate-functions/max-by.md    |  127 ++
 .../sql-functions/aggregate-functions/max-map.md   |  115 ++
 .../sql-functions/aggregate-functions/max.md       |  136 +++
 .../sql-functions/aggregate-functions/median.md    |   73 ++
 .../sql-functions/aggregate-functions/min-by.md    |  127 ++
 .../sql-functions/aggregate-functions/min-map.md   |  115 ++
 .../sql-functions/aggregate-functions/min.md       |  135 +++
 .../aggregate-functions/percentile-approx-array.md |  108 ++
 .../percentile-approx-weighted.md                  |  109 ++
 .../aggregate-functions/percentile-approx.md       |  105 ++
 .../aggregate-functions/percentile-array.md        |  104 ++
 .../aggregate-functions/percentile.md              |  103 ++
 .../aggregate-functions/percentile_reservoir.md    |   90 ++
 .../aggregate-functions/quantile-union.md          |   93 ++
 .../sql-functions/aggregate-functions/regr-avgx.md |   64 +
 .../sql-functions/aggregate-functions/regr-avgy.md |   64 +
 .../aggregate-functions/regr-count.md              |   66 ++
 .../aggregate-functions/regr-intercept.md          |   64 +
 .../sql-functions/aggregate-functions/regr-r2.md   |   75 ++
 .../aggregate-functions/regr-slope.md              |   64 +
 .../sql-functions/aggregate-functions/regr-sxx.md  |   64 +
 .../sql-functions/aggregate-functions/regr-sxy.md  |   64 +
 .../sql-functions/aggregate-functions/regr-syy.md  |   64 +
 .../sql-functions/aggregate-functions/retention.md |  165 +++
 .../sql-functions/aggregate-functions/sem.md       |  106 ++
 .../aggregate-functions/sequence-count.md          |  187 +++
 .../aggregate-functions/sequence-match.md          |  184 +++
 .../sql-functions/aggregate-functions/skew.md      |   93 ++
 .../aggregate-functions/stddev-samp.md             |   60 +
 .../sql-functions/aggregate-functions/stddev.md    |   65 ++
 .../sql-functions/aggregate-functions/sum-map.md   |  111 ++
 .../sql-functions/aggregate-functions/sum.md       |   61 +
 .../sql-functions/aggregate-functions/sum0.md      |   64 +
 .../aggregate-functions/topn-array.md              |   89 ++
 .../aggregate-functions/topn-weighted.md           |   93 ++
 .../sql-functions/aggregate-functions/topn.md      |   90 ++
 .../sql-functions/aggregate-functions/var-samp.md  |   68 ++
 .../sql-functions/aggregate-functions/variance.md  |   65 ++
 .../aggregate-functions/window-funnel.md           |  286 +++++
 .../sql-functions/ai-functions/ai-classify.md      |   77 ++
 .../sql-functions/ai-functions/ai-extract.md       |   79 ++
 .../sql-functions/ai-functions/ai-filter.md        |   81 ++
 .../sql-functions/ai-functions/ai-fixgrammar.md    |   76 ++
 .../sql-functions/ai-functions/ai-generate.md      |   76 ++
 .../sql-functions/ai-functions/ai-mask.md          |   79 ++
 .../sql-functions/ai-functions/ai-sentiment.md     |   80 ++
 .../sql-functions/ai-functions/ai-similarity.md    |   86 ++
 .../sql-data-types/numeric/LARGEINT.json           |   49 +
 .../sql-data-types/numeric/SMALLINT.json           |   49 +
 .../sql-data-types/numeric/TINYINT.json            |   49 +
 .../sql-data-types/semi-structured/ARRAY.json      |   37 +
 .../sql-data-types/semi-structured/GEO.json        |   49 +
 .../sql-data-types/semi-structured/JSON.json       |   37 +
 .../sql-data-types/semi-structured/MAP.json        |   37 +
 .../sql-data-types/semi-structured/STRUCT.json     |   37 +
 .../sql-data-types/semi-structured/VARIANT.json    |   46 +
 .../semi-structured/variant-workload-guide.json    |   37 +
 .../sql-data-types/string-type/CHAR.json           |   49 +
 .../sql-data-types/string-type/STRING.json         |   49 +
 .../sql-data-types/string-type/VARCHAR.json        |   49 +
 .../4.x/sql-manual/basic-element/variables.json    |   49 +
 .../sql-functions/aggregate-functions/ai-agg.json  |   49 +
 .../aggregate-functions/any-value.json             |   37 +
 .../aggregate-functions/approx-count-distinct.json |   37 +
 .../aggregate-functions/array-agg.json             |   37 +
 .../sql-functions/aggregate-functions/avg-map.json |   49 +
 .../aggregate-functions/avg-weighted.json          |   49 +
 .../sql-functions/aggregate-functions/avg.json     |   49 +
 .../aggregate-functions/bitmap-agg.json            |   37 +
 .../aggregate-functions/bitmap-intersect.json      |   49 +
 .../aggregate-functions/bitmap-union-count.json    |   49 +
 .../aggregate-functions/bitmap-union-int.json      |   37 +
 .../aggregate-functions/bitmap-union.json          |   49 +
 .../aggregate-functions/bool-and.json              |   49 +
 .../sql-functions/aggregate-functions/bool-or.json |   49 +
 .../aggregate-functions/bool-xor.json              |   49 +
 .../aggregate-functions/collect-list.json          |   37 +
 .../aggregate-functions/collect-set.json           |   37 +
 .../aggregate-functions/corr-welford.json          |   37 +
 .../sql-functions/aggregate-functions/corr.json    |   49 +
 .../aggregate-functions/count-by-enum.json         |   49 +
 .../aggregate-functions/count-map.json             |   49 +
 .../sql-functions/aggregate-functions/count.json   |   49 +
 .../aggregate-functions/covar-samp.json            |   49 +
 .../sql-functions/aggregate-functions/covar.json   |   49 +
 .../datasketches_hll_union_agg.json                |   37 +
 .../aggregate-functions/group-array-intersect.json |   49 +
 .../aggregate-functions/group-array-union.json     |   49 +
 .../aggregate-functions/group-bit-and.json         |   49 +
 .../aggregate-functions/group-bit-or.json          |   49 +
 .../aggregate-functions/group-bit-xor.json         |   49 +
 .../aggregate-functions/group-bitmap-xor.json      |   49 +
 .../aggregate-functions/group-concat.json          |   49 +
 .../aggregate-functions/histogram.json             |   37 +
 .../aggregate-functions/hll-raw-agg.json           |   49 +
 .../aggregate-functions/hll-union-agg.json         |   49 +
 .../aggregate-functions/intersect-count.json       |   37 +
 .../sql-functions/aggregate-functions/kurt.json    |   49 +
 .../aggregate-functions/linear-histogram.json      |   49 +
 .../sql-functions/aggregate-functions/map-agg.json |   37 +
 .../sql-functions/aggregate-functions/max-by.json  |   37 +
 .../sql-functions/aggregate-functions/max-map.json |   49 +
 .../sql-functions/aggregate-functions/max.json     |   37 +
 .../sql-functions/aggregate-functions/median.json  |   37 +
 .../sql-functions/aggregate-functions/min-by.json  |   37 +
 .../sql-functions/aggregate-functions/min-map.json |   49 +
 .../sql-functions/aggregate-functions/min.json     |   37 +
 .../percentile-approx-array.json                   |   49 +
 .../percentile-approx-weighted.json                |   49 +
 .../aggregate-functions/percentile-approx.json     |   49 +
 .../aggregate-functions/percentile-array.json      |   49 +
 .../aggregate-functions/percentile.json            |   49 +
 .../aggregate-functions/percentile_reservoir.json  |   49 +
 .../aggregate-functions/quantile-union.json        |   49 +
 .../aggregate-functions/regr-avgx.json             |   49 +
 .../aggregate-functions/regr-avgy.json             |   49 +
 .../aggregate-functions/regr-count.json            |   49 +
 .../aggregate-functions/regr-intercept.json        |   49 +
 .../sql-functions/aggregate-functions/regr-r2.json |   49 +
 .../aggregate-functions/regr-slope.json            |   49 +
 .../aggregate-functions/regr-sxx.json              |   49 +
 .../aggregate-functions/regr-sxy.json              |   49 +
 .../aggregate-functions/regr-syy.json              |   49 +
 .../aggregate-functions/retention.json             |   49 +
 .../sql-functions/aggregate-functions/sem.json     |   49 +
 .../aggregate-functions/sequence-count.json        |   37 +
 .../aggregate-functions/sequence-match.json        |   37 +
 .../sql-functions/aggregate-functions/skew.json    |   49 +
 .../aggregate-functions/stddev-samp.json           |   49 +
 .../sql-functions/aggregate-functions/stddev.json  |   49 +
 .../sql-functions/aggregate-functions/sum-map.json |   49 +
 .../sql-functions/aggregate-functions/sum.json     |   49 +
 .../sql-functions/aggregate-functions/sum0.json    |   49 +
 .../aggregate-functions/topn-array.json            |   37 +
 .../aggregate-functions/topn-weighted.json         |   37 +
 .../sql-functions/aggregate-functions/topn.json    |   37 +
 .../aggregate-functions/var-samp.json              |   49 +
 .../aggregate-functions/variance.json              |   49 +
 .../aggregate-functions/window-funnel.json         |   37 +
 .../sql-functions/ai-functions/ai-classify.json    |   49 +
 .../sql-functions/ai-functions/ai-extract.json     |   49 +
 .../sql-functions/ai-functions/ai-filter.json      |   49 +
 .../sql-functions/ai-functions/ai-fixgrammar.json  |   49 +
 .../sql-functions/ai-functions/ai-generate.json    |   49 +
 .../sql-functions/ai-functions/ai-mask.json        |   49 +
 .../sql-functions/ai-functions/ai-sentiment.json   |   49 +
 .../sql-functions/ai-functions/ai-similarity.json  |   49 +
 200 files changed, 16614 insertions(+)

diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/LARGEINT.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/LARGEINT.md
new file mode 100644
index 00000000000..40b9fc33fc4
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/LARGEINT.md
@@ -0,0 +1,15 @@
+---
+{
+    "title": "LARGEINT",
+    "language": "ko",
+    "description": "LARGEINT 16바이트 부호 있는 정수, 범위 [-2^127 + 1 ~ 2^127 - 1]"
+}
+---
+
+## LARGEINT {#largeint}
+### 설명 {#description}
+LARGEINT
+16바이트 부호 있는 정수, 범위 [-2^127 + 1 ~ 2^127 - 1]
+
+### 키워드 {#keywords}
+LARGEINT
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/SMALLINT.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/SMALLINT.md
new file mode 100644
index 00000000000..8cca50f6d59
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/SMALLINT.md
@@ -0,0 +1,15 @@
+---
+{
+    "title": "SMALLINT",
+    "language": "ko",
+    "description": "SMALLINT 2바이트 부호 있는 정수, 범위 [-32768, 32767]"
+}
+---
+
+## SMALLINT {#smallint}
+### 설명 {#description}
+SMALLINT
+2바이트 부호 있는 정수, 범위 [-32768, 32767]
+
+### 키워드 {#keywords}
+SMALLINT
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/TINYINT.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/TINYINT.md
new file mode 100644
index 00000000000..62923c5301a
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/numeric/TINYINT.md
@@ -0,0 +1,15 @@
+---
+{
+    "title": "TINYINT",
+    "language": "ko",
+    "description": "TINYINT 1바이트 부호 있는 정수, 범위 [-128, 127]"
+}
+---
+
+## TINYINT {#tinyint}
+### 설명 {#description}
+TINYINT
+1바이트 부호 있는 정수, 범위 [-128, 127]
+
+### 키워드 {#keywords}
+TINYINT
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/ARRAY.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/ARRAY.md
new file mode 100644
index 00000000000..9a11dfef2fe
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/ARRAY.md
@@ -0,0 +1,330 @@
+---
+{
+    "title": "ARRAY | 반정형",
+    "language": "ko",
+    "description": "ARRAY<T> 타입은 각 요소의 데이터 타입이 동일한 순서 있는 컬렉션을 나타내는 데 사용됩니다. 예를 들어,",
+    "sidebar_label": "ARRAY"
+}
+---
+
+# ARRAY 문서 {#array-documentation}
+
+## 타입 설명 {#type-description}
+
+`ARRAY<T>` 타입은 각 요소의 데이터 타입이 동일한 순서 있는 컬렉션을 나타내는 데 사용됩니다. 예를 들어 정수 배열은 `[1, 2, 3]`으로, 문자열 배열은 `["a", "b", "c"]`로 표현할 수 있습니다.
+
+- `ARRAY<T>`는 T 타입의 요소로 구성된 배열을 나타내며, T는 NULL을 허용합니다. T로 지원되는 타입은 다음과 같습니다: `BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL, DATE, DATETIME, TIMESTAMPTZ, CHAR, VARCHAR, STRING, IPV4, IPV6, STRUCT, MAP, VARIANT, JSONB, ARRAY<T>`.
+  - 참고: 위의 T 타입 중 `JSONB`와 `VARIANT`는 Doris의 연산 계층에서만 지원되며, **Doris에서 테이블을 생성할 때 `ARRAY<JSONB>`와 `ARRAY<VARIANT>`를 사용하는 것은 지원되지 않습니다**.
+
+## 타입 제약 사항 {#type-constraints}
+
+- `ARRAY<T>` 타입이 지원하는 최대 중첩 깊이는 9입니다.
+- `ARRAY<T>` 타입 간 변환은 T의 변환 가능 여부에 따라 결정됩니다. `Array<T>` 타입은 다른 타입으로 변환할 수 없습니다.
+  - 예: `ARRAY<INT>`는 `ARRAY<BIGINT>`로 변환할 수 있습니다. `INT`와 `BIGINT` 간에 변환이 가능하기 때문입니다.
+  - `Variant` 타입은 `Array<T>` 타입으로 변환할 수 있습니다.
+  - 문자열 타입은 `ARRAY<T>` 타입으로 변환할 수 있습니다(파싱을 통해 변환하며, 파싱에 실패하면 NULL을 반환합니다).
+- `AGGREGATE` 테이블 모델에서 `ARRAY<T>` 타입은 `REPLACE`와 `REPLACE_IF_NOT_NULL`만 지원합니다. **어떤 테이블 모델에서도 KEY 컬럼이나 파티션 컬럼, 버킷 컬럼으로 사용할 수 없습니다**.
+- `ARRAY<T>` 타입의 컬럼은 **`ORDER BY`와 `GROUP BY` 연산을 지원합니다**.
+  - `ORDER BY`와 `GROUP BY`를 지원하는 T 타입은 다음과 같습니다: `BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL, DATE, DATETIME, TIMESTAMPTZ, CHAR, VARCHAR, STRING, IPV4, IPV6`.
+- `ARRAY<T>` 타입의 컬럼은 `IN` 또는 `NOT IN` 연산을 지원하지 않습니다.
+- `ARRAY<T>` 타입의 컬럼은 `JOIN KEY`로 사용할 수 없으며 `DELETE` 문에서도 사용할 수 없습니다.
+
+## 상수 생성 {#constant-construction}
+
+- `ARRAY()` 함수를 사용하여 `ARRAY<T>` 타입의 값을 생성합니다. T는 매개변수들의 공통 타입입니다.
+    
+    ```SQL
+    -- [1, 2, 3] T is INT
+    SELECT ARRAY(1, 2, 3);
+
+    -- ["1", "2", "abc"] , T is STRING
+    SELECT ARRAY(1, 2, 'abc');
+    ```
+- `[]`를 사용하여 `ARRAY<T>` 타입의 값을 생성합니다. T는 매개변수들의 공통 타입입니다.
+  
+   ```SQL
+    -- ["abc", "def", "efg"] T is STRING
+    SELECT ["abc", "def", "efg"];
+
+    -- ["1", "2", "abc"] , T is STRING
+    SELECT [1, 2, 'abc'];
+    ```
+
+## 타입 변경 {#modifying-type}
+
+- `ARRAY` 내부의 요소 타입이 `VARCHAR`인 경우에만 변경할 수 있습니다.
+   - `VARCHAR`의 매개변수 값은 작은 값에서 큰 값으로만 변경할 수 있으며, 그 반대로는 변경할 수 없습니다.
+
+    ```SQL
+    CREATE TABLE `array_table` (
+      `k` INT NOT NULL,
+      `array_column` ARRAY<VARCHAR(10)>
+    ) ENGINE=OLAP
+    DUPLICATE KEY(`k`)
+    DISTRIBUTED BY HASH(`k`) BUCKETS 1
+    PROPERTIES (
+        "replication_num" = "1"
+    );
+
+    ALTER TABLE array_table MODIFY COLUMN array_column ARRAY<VARCHAR(20)>;
+    ```
+- `ARRAY<T>` 타입 컬럼의 기본값은 NULL로만 지정할 수 있으며, 한 번 지정하면 변경할 수 없습니다.
+
+## 요소 접근 {#element-access}
+
+- `[k]`를 사용하여 `ARRAY<T>`의 k번째 요소에 접근합니다. k는 1부터 시작하며, 범위를 벗어나면 NULL을 반환합니다.
+
+  ```SQL
+  SELECT [1, 2, 3][1];
+    +--------------+
+    | [1, 2, 3][1] |
+    +--------------+
+    |            1 |
+    +--------------+
+
+  SELECT ARRAY(1, 2, 3)[2];
+    +-------------------+
+    | ARRAY(1, 2, 3)[2] |
+    +-------------------+
+    |                 2 |
+    +-------------------+
+
+  SELECT [[1,2,3],[2,3,4]][1][3];
+    +-------------------------+
+    | [[1,2,3],[2,3,4]][1][3] |
+    +-------------------------+
+    |                       3 |
+    +-------------------------+
+  ```
+
+- `ELEMENT_AT(ARRAY, k)`를 사용하여 `ARRAY<T>`의 k번째 요소에 접근합니다. k는 1부터 시작하며, 범위를 벗어나면 NULL을 반환합니다.
+  
+  ```SQL
+  SELECT ELEMENT_AT(ARRAY(1, 2, 3) , 2);
+  +--------------------------------+
+  | ELEMENT_AT(ARRAY(1, 2, 3) , 2) |
+  +--------------------------------+
+  |                              2 |
+  +--------------------------------+
+
+  SELECT ELEMENT_AT([1, 2, 3] , 3);
+  +---------------------------+
+  | ELEMENT_AT([1, 2, 3] , 3) |
+  +---------------------------+
+  |                         3 |
+  +---------------------------+
+
+  SELECT ELEMENT_AT([["abc", "def"], ["def", "gef"], [3]] , 3);                      
+  +-------------------------------------------------------+
+  | ELEMENT_AT([["abc", "def"], ["def", "gef"], [3]] , 3) |
+  +-------------------------------------------------------+
+  | ["3"]                                                 |
+  +-------------------------------------------------------+
+  ```
+
+## 비교 관계 {#comparison-relationship}
+
+ARRAY는 순서가 있는 타입이므로 [1, 2, 3]과 [3, 2, 1]은 서로 다른 두 ARRAY입니다. 두 ARRAY의 요소를 순서대로 하나씩 비교했을 때 모든 요소가 같은 경우에만 두 ARRAY가 같습니다:
+
+```sql
+select array(1,2,3) = array(3,2,1);
++-----------------------------+
+| array(1,2,3) = array(3,2,1) |
++-----------------------------+
+|                           0 |
++-----------------------------+
+
+select array(1,2,3) = array(1,2,3);
++-----------------------------+
+| array(1,2,3) = array(1,2,3) |
++-----------------------------+
+|                           1 |
++-----------------------------+
+
+select array(1,2,3) = array(1,2,3,3);
++-------------------------------+
+| array(1,2,3) = array(1,2,3,3) |
++-------------------------------+
+|                             0 |
++-------------------------------+
+```
+
+부분 순서 비교에서 ARRAY는 사전식 순서를 따릅니다. 두 배열 `A`와 `B`가 주어지면 인덱스 `i = 1`부터 시작하여 같은 위치에 있는 요소 `A[i]`와 `B[i]`를 비교합니다:
+
+- `A[i] ≠ B[i]`로 서로 다르면 비교 결과(<, >)가 배열 전체의 비교 결과를 바로 결정합니다
+- `A[i] = B[i]`이면 다음 위치의 요소를 계속 비교합니다
+- 두 배열의 공통 길이 범위 내 모든 요소가 같으면 길이가 짧은 배열이 더 작습니다.
+
+```sql
+select array(1,2,3) > array(1,2,3,3), array(1,2,3) < array(1,2,3,3);
++-------------------------------+-------------------------------+
+| array(1,2,3) > array(1,2,3,3) | array(1,2,3) < array(1,2,3,3) |
++-------------------------------+-------------------------------+
+|                             0 |                             1 |
++-------------------------------+-------------------------------+
+
+select array(1,3,2) > array(1,2,3), array(1,3,2) < array(1,2,3);
++-----------------------------+-----------------------------+
+| array(1,3,2) > array(1,2,3) | array(1,3,2) < array(1,2,3) |
++-----------------------------+-----------------------------+
+|                           1 |                           0 |
++-----------------------------+-----------------------------+
+
+select array(null) < array(-1), array(null) > array(-1);
++-------------------------+-------------------------+
+| array(null) < array(-1) | array(null) > array(-1) |
++-------------------------+-------------------------+
+|                       1 |                       0 |
++-------------------------+-------------------------+
+```
+
+## 쿼리 가속 {#query-acceleration}
+
+- Doris 테이블의 `ARRAY<T>` 타입 컬럼에는 역색인을 추가하여 해당 컬럼의 `ARRAY` 함수를 사용하는 연산을 가속할 수 있습니다.
+  - 역색인에서 지원하는 T 타입: `BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, DECIMAL, DATE, DATETIME, TIMESTAMPTZ, CHAR, VARCHAR, STRING, IPV4, IPV6`.
+  - 가속되는 `ARRAY` 함수: `ARRAY_CONTAINS`, `ARRAYS_OVERLAP`. 단, 함수 매개변수에 NULL이 포함되면 일반 벡터화 연산으로 전환됩니다.
+
+## 예제 {#examples}
+
+- 다차원 배열
+
+  ```SQL
+  -- Create table
+  CREATE TABLE IF NOT EXISTS array_table (
+      id INT,
+      two_dim_array ARRAY<ARRAY<INT>>,
+      three_dim_array ARRAY<ARRAY<ARRAY<STRING>>>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(id)
+  DISTRIBUTED BY HASH(id) BUCKETS 1
+  PROPERTIES (
+      "replication_num" = "1"
+  );
+
+  -- Insert
+  INSERT INTO array_table VALUES (1, [[1, 2, 3], [4, 5, 6]], [[['ab', 'cd', 'ef'], ['gh', 'ij', 'kl']], [['mn', 'op', 'qr'], ['st', 'uv', 'wx']]]);
+
+  INSERT INTO array_table VALUES (2, ARRAY(ARRAY(1, 2, 3), ARRAY(4, 5, 6)), ARRAY(ARRAY(ARRAY('ab', 'cd', 'ef'), ARRAY('gh', 'ij', 'kl')), ARRAY(ARRAY('mn', 'op', 'qr'), ARRAY('st', 'uv', 'wx'))));
+
+  -- Query
+  SELECT two_dim_array[1][2], three_dim_array[1][1][2] FROM array_table ORDER BY id;
+  +---------------------+--------------------------+
+  | two_dim_array[1][2] | three_dim_array[1][1][2] |
+  +---------------------+--------------------------+
+  |                   2 | cd                       |
+  |                   2 | cd                       |
+  +---------------------+--------------------------+
+  ```
+
+- 중첩 복합 타입
+  
+  ```SQL
+  -- Create table
+  CREATE TABLE IF NOT EXISTS array_map_table (
+      id INT,
+      array_map ARRAY<MAP<STRING, INT>>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(id)
+  DISTRIBUTED BY HASH(id) BUCKETS 1
+  PROPERTIES (
+      "replication_num" = "1"
+  );
+
+  -- Insert
+  INSERT INTO array_map_table VALUES (1, ARRAY(MAP('key1', 1), MAP('key2', 2)));
+  INSERT INTO array_map_table VALUES (2, ARRAY(MAP('key1', 1), MAP('key2', 2)));
+
+  -- Query
+  SELECT array_map[1], array_map[2] FROM array_map_table ORDER BY id;
+  +--------------+--------------+
+  | array_map[1] | array_map[2] |
+  +--------------+--------------+
+  | {"key1":1}   | {"key2":2}   |
+  | {"key1":1}   | {"key2":2}   |
+  +--------------+--------------+
+
+  -- Create table
+  CREATE TABLE IF NOT EXISTS array_table (
+      id INT,
+      array_struct ARRAY<STRUCT<id: INT, name: STRING>>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(id)
+  DISTRIBUTED BY HASH(id) BUCKETS 1
+  PROPERTIES (
+      "replication_num" = "1"
+  );
+
+  INSERT INTO array_table VALUES (1, ARRAY(STRUCT(1, 'John'), STRUCT(2, 'Jane')));
+  INSERT INTO array_table VALUES (2, ARRAY(STRUCT(1, 'John'), STRUCT(2, 'Jane')));
+
+  SELECT array_struct[1], array_struct[2] FROM array_table ORDER BY id;
+  +-------------------------+-------------------------+
+  | array_struct[1]         | array_struct[2]         |
+  +-------------------------+-------------------------+
+  | {"id":1, "name":"John"} | {"id":2, "name":"Jane"} |
+  | {"id":1, "name":"John"} | {"id":2, "name":"Jane"} |
+  +-------------------------+-------------------------+
+  ```
+
+- 타입 변경
+
+  ```SQL
+  -- Create table
+  CREATE TABLE array_table (
+      id INT,
+      array_varchar ARRAY<VARCHAR(10)>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(id)
+  DISTRIBUTED BY HASH(id) BUCKETS 1
+  PROPERTIES (
+      "replication_allocation" = "tag.location.default: 1"
+  );
+
+  -- Modify ARRAY type
+  ALTER TABLE array_table MODIFY COLUMN array_varchar ARRAY<VARCHAR(20)>;
+
+  -- Check column type
+  DESC array_table;
+  +---------------+--------------------+------+-------+---------+-------+
+  | Field         | Type               | Null | Key   | Default | Extra |
+  +---------------+--------------------+------+-------+---------+-------+
+  | id            | int                | Yes  | true  | NULL    |       |
+  | array_varchar | array<varchar(20)> | Yes  | false | NULL    | NONE  |
+  +---------------+--------------------+------+-------+---------+-------+
+  ```
+
+- 역색인
+
+  ```SQL
+  -- Create table statement
+  CREATE TABLE `array_table` (
+    `k` int NOT NULL,
+    `array_column` ARRAY<INT>,
+    INDEX idx_array_column (array_column) USING INVERTED
+  ) ENGINE=OLAP
+  DUPLICATE KEY(`k`)
+  DISTRIBUTED BY HASH(`k`) BUCKETS 1
+  PROPERTIES (
+      "replication_num" = "1"
+  );
+
+  -- Insert
+  INSERT INTO array_table VALUES (1, [1, 2, 3]), (2, [4, 5, 6]), (3, [7, 8, 9]);
+
+  -- The inverted index accelerates the execution of the ARRAY_CONTAINS function
+  SELECT * FROM array_table WHERE ARRAY_CONTAINS(array_column, 5);
+  +------+--------------+
+  | k    | array_column |
+  +------+--------------+
+  |    2 | [4, 5, 6]    |
+  +------+--------------+
+
+  -- The inverted index accelerates the execution of the ARRAYS_OVERLAP function
+  SELECT * FROM array_table WHERE ARRAYS_OVERLAP(array_column, [6, 9]);
+  +------+--------------+
+  | k    | array_column |
+  +------+--------------+
+  |    2 | [4, 5, 6]    |
+  |    3 | [7, 8, 9]    |
+  +------+--------------+
+  ```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/GEO.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/GEO.md
new file mode 100644
index 00000000000..d41305150cc
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/GEO.md
@@ -0,0 +1,397 @@
+---
+{
+    "title": "GEO",
+    "language": "ko",
+    "description": "지리 공간 타입은 데이터베이스에서 지리 공간 데이터를 저장하고 처리하는 데 사용하는 특수 데이터 타입입니다."
+}
+---
+
+:::info
+이 문서에서 설명하는 GEO 타입은 Doris의 실제 데이터 타입이 아니라, String/Varchar 타입을 기반으로 저장하는 특정 데이터 형식과 관련 함수의 사용 방법을 의미합니다.
+:::
+
+지리 공간 타입은 데이터베이스에서 지리 공간 데이터를 저장하고 처리하는 데 사용하는 특수 데이터 타입으로, 점, 선, 다각형 등의 기하 객체를 표현할 수 있습니다. 주요 용도는 다음과 같습니다.
+- 지리적 위치 정보 저장(예: 경도와 위도).
+- 공간 쿼리 지원(예: 거리 계산, 영역 포함 여부, 교차 여부 판정).
+- 지리 공간 분석 수행(예: 버퍼 분석, 경로 계획).
+지리 정보 시스템은 지도 서비스, 물류 배차, 위치 기반 소셜 네트워킹, 기상 관측 등에 널리 사용됩니다. 핵심 요구 사항은 대규모 공간 데이터를 효율적으로 저장하고 지연 시간이 짧은 공간 연산을 지원하는 것입니다.
+
+
+## 핵심 인코딩 기술 {#core-encoding-technologies}
+### S2 Geometry Library {#s2-geometry-library}
+S2 Geometry는 Google이 개발한 구면 기하 인코딩 시스템입니다. 핵심 아이디어는 구면을 평면에 투영하여 전 세계 지리 공간 데이터를 효율적으로 인덱싱하는 것입니다.
+
+#### 핵심 원리 {#core-principles}
+- 구면 투영: 지구의 구면을 정육면체의 6개 면에 투영하여 3D 구면 데이터를 2D 평면 데이터로 변환합니다.
+- 계층적 격자 분할: 각 면을 사각형 격자(셀)로 재귀적으로 나누고, 각 셀을 다시 4개의 작은 하위 셀로 분할하여 30단계 정밀도의 계층 구조를 형성합니다(단계가 높을수록 셀 면적이 작아지고 정밀도가 높아집니다).
+- 64비트 인코딩: 각 셀에 고유한 64비트 ID를 할당합니다. 이 ID로 공간상의 위치를 빠르게 찾고 공간 관계를 판정할 수 있습니다.
+- Hilbert 곡선 정렬: Hilbert 공간 채움 곡선으로 셀을 인코딩하여 공간적으로 인접한 셀이 연속된 ID를 갖도록 하고 범위 쿼리 성능을 최적화합니다.
+
+#### 장점 {#advantages}
+- 높은 정밀도와 점진적인 전환: 30단계 계층 구조를 통해 전 지구 규모(단계 0)부터 센티미터 수준(단계 30)까지 정밀도를 점진적으로 전환하여 다양한 시나리오의 요구를 충족합니다.
+- 전 지구 범위 쿼리의 효율성: 대륙 간, 국가 간 지역 분석과 같은 대규모 공간 쿼리에 적합하며, 성능이 크게 저하되지 않습니다.
+- 효율적인 공간 관계 계산: 셀 ID로 포함, 교차 등의 관계를 빠르게 판정하여 복잡한 기하 연산을 피할 수 있습니다.
+
+
+### GeoHash 인코딩 {#geohash-encoding}
+GeoHash는 등거리 원통 도법을 기반으로 하는 지리 인코딩 방식으로, 경도와 위도를 문자열로 변환하여 공간 인덱싱을 구현합니다.
+
+#### 핵심 원리 {#core-principles-1}
+- 평면 투영: 지구의 구면을 평면으로 근사하고, 경도와 위도를 이진 분할하여 영역을 재귀적으로 나눕니다.
+- 직사각형 격자 분할: 지표면을 정밀도가 서로 다른 직사각형 셀로 나눕니다. 문자열 길이가 정밀도를 결정하며(최대 12자), 문자가 하나 추가될 때마다 정밀도가 약 10배 높아집니다.
+- Z-order 곡선 인코딩: 경도와 위도의 이진 비트를 번갈아 취하여 Z-order 곡선을 형성하고, 2D 좌표를 1D 문자열로 변환합니다.
+
+#### 특징 {#features}
+- 인덱싱 편의성: 문자열 접두사 매칭으로 인접 영역을 빠르게 쿼리할 수 있습니다(예: 접두사가 같은 GeoHash 코드는 공간적으로 인접한 영역에 해당합니다).
+- 한계:
+  - 제한된 정밀도 단계: 최대 12단계이며, 단계 간 변화 폭이 커서 정밀도를 점진적으로 높이는 고정밀 분할 요구를 충족하기 어렵습니다.
+  - Z-order 곡선의 가변성: 곡선의 도약으로 인해 공간적으로 인접한 영역의 코드가 불연속적일 수 있어 범위 쿼리의 정확도에 영향을 줍니다.
+  - 대규모 쿼리의 낮은 효율성: 전 지구 범위를 쿼리할 때 분산된 셀을 대량으로 스캔해야 하므로 성능이 떨어집니다.
+
+
+### 종합 비교 및 선택 {#comprehensive-comparison-and-selection}
+S2 Geometry Library와 GeoHash의 특성을 종합적으로 비교한 결과, 지리 공간 처리를 위한 서드파티 종속성으로 S2 Geometry Library를 선택했습니다. 주요 이유는 다음과 같습니다.
+- 전 지구 범위 쿼리에 대한 적합성: S2의 계층적 격자 설계는 대규모 공간 분석에 더 적합한 반면, GeoHash는 여러 지역에 걸친 쿼리에서 성능 병목이 발생합니다.
+- 정밀도와 점진적 전환: S2의 30단계 계층 구조는 전 지구 규모부터 센티미터 수준까지 정밀도를 점진적으로 전환하여 다양한 시나리오의 정밀도 요구를 충족하며, GeoHash의 12단계 분할보다 우수합니다.
+- 공간적 연속성: Hilbert 곡선은 Z-order 곡선보다 공간적 연속성이 뛰어나 범위 쿼리의 중복 계산을 줄일 수 있습니다.
+
+
+## WKT 소개 {#introduction-to-wkt}
+WKT(Well-Known Text)는 지리 공간 데이터를 표현하는 표준 텍스트 형식입니다.
+
+### 정의 {#definition}
+- 텍스트 형식: 텍스트 문자열로 기하 객체의 구조와 좌표를 기술합니다.
+- 특징: 사람이 읽기 쉽고 편집하기 쉬우며, 수동 입력이나 간단한 데이터 교환에 적합합니다.
+
+### 구문 구조 {#syntax-structure}
+- 기본 형식: GeometryType(CoordinateValues)
+- 일반적인 기하 타입:
+  - Point: POINT(longitude, latitude)  
+    예: POINT(112.46, 45.23)는 한 점의 경도와 위도를 나타냅니다.
+  - LineString: LINESTRING(point1, point2)  
+    예: LINESTRING(0 0, 1 1)은 두 점을 연결하는 선분을 나타냅니다.
+  - Polygon: POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))
+
+
+## WKB 소개 {#introduction-to-wkb}
+WKB(Well-Known Binary)는 지리 공간 데이터를 표현하는 표준 바이너리 데이터 형식입니다.
+
+### 정의 {#definition-1}
+- 바이너리 형식: 바이너리 인코딩으로 기하 객체를 표현하며, WKT보다 간결하고 효율적입니다.
+- 특징: 컴퓨터의 내부 저장과 전송에 최적화되어 있어 공간을 절약하고 빠르게 파싱할 수 있습니다.
+
+### 인코딩 구조 {#encoding-structure}
+WKB는 다음 부분으로 구성됩니다.
+- 바이트 순서(1바이트):
+  - 0x00: Big Endian(네트워크 바이트 순서)
+  - 0x01: Little Endian(Intel/AMD 아키텍처에서 일반적으로 사용)
+- 기하 타입(4바이트 정수):
+  - 1: Point
+  - 2: LineString
+  - 3: Polygon
+  - ... (기타 타입)
+- 좌표값:
+  - Point: x, y(또는 x, y, z)
+  - LineString: point1의 좌표, point2의 좌표
+  - Polygon: point1의 좌표, point2의 좌표...
+
+#### 예제 {#example}
+```sql
+    01 01 00 00 00 00 00 00 00 00 F0 3F 00 00 00 00 00 00 00 40
+    └─┘ └─┘ └───────────────┘ └───────────────┘
+    │   │         │               │
+    Little Endian Point type     x=1.0           y=2.0
+```
+
+## GeoPoint 타입 {#geopoint-type}
+1. String 또는 Varchar를 사용하여 WKT 형식 저장
+
+```sql
+CREATE TABLE simple_point (  id INT,  wkt STRING) ;
+INSERT INTO simple_point VALUES(1,'POINT(121.4737 31.2304)');
+
+create table simple_point(id int, wkt VARCHAR(255));
+INSERT INTO simple_point VALUES(1,'POINT(121.4737 31.2304)');
+```
+
+
+WKT 형식 쿼리
+
+```sql
+select st_astext(st_geometryfromtext(wkt)) from simple_point;
++-------------------------------------+
+| st_astext(st_geometryfromtext(wkt)) |
++-------------------------------------+
+| POINT (121.4737 31.2304)            |
++-------------------------------------+
+```
+
+2. WKB 형식으로 저장
+
+```sql
+CREATE TABLE simple_point (  id INT,  wkb STRING) ;
+INSERT INTO simple_point VALUES(1,'\x01010000005f07ce19515e5e4097ff907efb3a3f40');
+
+create table simple_point(id int, wkb VARCHAR(255));
+INSERT INTO simple_point VALUES(1,'\x01010000005f07ce19515e5e4097ff907efb3a3f40');
+
+```
+
+WKB 형식 쿼리
+
+```sql
+select st_astext(st_geometryfromwkb(wkb)) from simple_point;
++------------------------------------+
+| st_astext(st_geometryfromwkb(wkb)) |
++------------------------------------+
+| POINT (121.4737 31.2304)           |
++------------------------------------+
+```
+
+3. 부동소수점 수로 좌표 저장(x는 위도, y는 경도)
+
+```sql
+CREATE TABLE simple_point_double (id INT,x DOUBLE,y DOUBLE) 
+INSERT INTO simple_point_double VALUES(0,1,2);
+```
+
+
+부동소수점 형식 쿼리
+
+```sql
+select st_astext(st_point(x,y)) from simple_point_double;
++--------------------------+
+| st_astext(st_point(x,y)) |
++--------------------------+
+| POINT (1 2)              |
++--------------------------+
+```
+
+
+## GeoLine 타입 {#geoline-type}
+
+1. String 또는 Varchar를 사용하여 WKT 형식 저장
+
+```sql
+CREATE TABLE simple_line (  id INT,  wkt STRING)
+INSERT INTO simple_line VALUES(1,'LINESTRING(116.4074 39.9042, 121.4737 31.2304)');
+
+CREATE TABLE simple_line (  id INT,  wkt VARCHAR(255))
+INSERT INTO simple_line VALUES(1,'LINESTRING(116.4074 39.9042, 121.4737 31.2304)');
+```
+
+
+WKT 형식 쿼리
+
+```sql
+select st_astext(st_linefromtext(wkt)) from simple_line;
++-------------------------------------------------+
+| st_astext(st_linefromtext(wkt))                 |
++-------------------------------------------------+
+| LINESTRING (116.4074 39.9042, 121.4737 31.2304) |
++-------------------------------------------------+
+```
+
+2. WKB 형식으로 저장
+
+```sql
+CREATE TABLE simple_line (  id INT,  wkb STRING)
+INSERT INTO simple_line VALUES(1,'\x010200000002000000fc1873d7121a5d4088855ad3bcf343405f07ce19515e5e4097ff907efb3a3f40');
+
+CREATE TABLE simple_line (  id INT,  wkb VARCHAR(255))
+INSERT INTO simple_line VALUES(1,'\x010200000002000000fc1873d7121a5d4088855ad3bcf343405f07ce19515e5e4097ff907efb3a3f40');
+```
+
+WKB 형식 쿼리
+
+```sql
+select st_astext(st_geometryfromwkb(wkb)) from simple_line;
++-------------------------------------------------+
+| st_astext(st_geometryfromwkb(wkb))              |
++-------------------------------------------------+
+| LINESTRING (116.4074 39.9042, 121.4737 31.2304) |
++-------------------------------------------------+
+```
+
+## GeoPolygon 타입 {#geopolygon-type}
+
+1. String 또는 Varchar를 사용하여 WKT 형식 저장
+
+```sql
+CREATE TABLE simple_polygon (  id INT,  wkt STRING)
+INSERT INTO simple_polygon VALUES(1,'POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))');
+
+CREATE TABLE simple_polygon (  id INT,  wkt VARCHAR(255))
+INSERT INTO simple_polygon VALUES(1,'POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))');
+```
+
+WKT 형식 쿼리
+
+```sql
+select st_astext(st_polygon(wkt)) from simple_polygon;
++------------------------------------------+
+| st_astext(st_polygon(wkt))               |
++------------------------------------------+
+| POLYGON ((10 0, 10 10, 0 10, 0 0, 10 0)) |
++------------------------------------------+
+```
+
+2. WKB 형식으로 저장
+
+```sql
+CREATE TABLE simple_polygon_wkb (  id INT,  wkb STRING)
+INSERT INTO simple_polygon_wkb VALUES(1,'\x010300000001000000050000000000000000002440000000000000000000000000000024400000000000002440000000000000000000000000000024400000000000000000000000000000000000000000000024400000000000000000');
+
+CREATE TABLE simple_polygon_wkb (  id INT,  wkb VARCHAR(255))
+INSERT INTO simple_polygon_wkb VALUES(1,'\x010300000001000000050000000000000000002440000000000000000000000000000024400000000000002440000000000000000000000000000024400000000000000000000000000000000000000000000024400000000000000000');
+```
+WKB 형식 쿼리
+
+```sql
+select st_astext(st_geometryfromwkb(wkb)) from simple_polygon_wkb;
++------------------------------------------+
+| st_astext(st_geometryfromwkb(wkb))       |
++------------------------------------------+
+| POLYGON ((10 0, 10 10, 0 10, 0 0, 10 0)) |
++------------------------------------------+
+```
+
+## GeoMultiPolygon 타입 {#geomultipolygon-type}
+
+
+1. String 또는 Varchar를 사용하여 WKT 형식 저장
+
+```sql
+CREATE TABLE simple_multipolygon (  id INT,  wkt STRING)
+INSERT INTO simple_multipolygon VALUES(1,'MULTIPOLYGON(((0 0, 0 10, 10 10, 10 0, 0 0)),((20 20, 20 30, 30 30, 30 20, 20 20)))');
+
+CREATE TABLE simple_multipolygon (  id INT,  wkt VARCHAR(255))
+INSERT INTO simple_multipolygon VALUES(1,'MULTIPOLYGON(((0 0, 0 10, 10 10, 10 0, 0 0)),  -- 第一个多边形((20 20, 20 30, 30 30, 30 20, 20 20))  -- 第二个多边形)');
+
+```
+
+
+WKT 형식 쿼리
+
+```sql
+select st_astext(st_geometryfromtext(wkt)) from simple_multipolygon;
++----------------------------------------------------------------------------------------+
+| st_astext(st_geometryfromtext(wkt))                                                    |
++----------------------------------------------------------------------------------------+
+| MULTIPOLYGON (((10 0, 10 10, 0 10, 0 0, 10 0)), ((30 20, 30 30, 20 30, 20 20, 30 20))) |
++----------------------------------------------------------------------------------------+
+```
+참고: GeoMultiPolygon의 WKB 형식 변환은 아직 지원되지 않습니다.
+
+## GeoCircle 타입 {#geocircle-type}
+
+저장 방법(부동소수점 수로 중심 좌표와 반지름 저장)
+원은 WKB 및 WKT 형식에 따르지 않으므로 중심 좌표(x, y)와 반지름(R)을 각각 저장하는 데 부동소수점 수 세 개가 필요합니다.
+
+```sql
+create table simple_circle(id int, X double,Y double, R double)
+INSERT INTO simple_circle VALUES(1,1.0,1.0,2);
+```
+원 쿼리
+
+```sql
+select st_astext(st_circle(X,Y,R)) from simple_circle;
++-----------------------------+
+| st_astext(st_circle(X,Y,R)) |
++-----------------------------+
+| CIRCLE ((1 1), 2)           |
++-----------------------------+
+```
+
+## 제약 사항 {#constraints}
+### 인덱스 {#index}
+Doris는 Geo 타입을 직접 구현하지 않고 WKT와 WKB를 사용하여 저장하고 변환하므로, 인덱싱 기술로 GEO 타입 쿼리를 가속할 수 없습니다.
+
+WKT를 GEO 출력으로 변환할 때는 13자리 정밀도만 보장됩니다.
+
+```sql
+mysql> SELECT ST_AsText(ST_GeometryFromText("POINT (1 3.1415926535897223)"));
++----------------------------------------------------------------+
+| ST_AsText(ST_GeometryFromText("POINT (1 3.1415926535897223)")) |
++----------------------------------------------------------------+
+| POINT (1 3.14159265358972)                                     |
++----------------------------------------------------------------+
+```
+
+
+바이너리를 GEO 출력으로 변환할 때는 13자리 정밀도만 보장됩니다.
+
+```sql
+mysql> select ST_AsText(ST_GeomFromWKB(ST_AsBinary(ST_Point(24.7,3.141592653589793))));
++--------------------------------------------------------------------------+
+| ST_AsText(ST_GeomFromWKB(ST_AsBinary(ST_Point(24.7,3.141592653589793)))) |
++--------------------------------------------------------------------------+
+| POINT (24.7 3.1415926535898)                                             |
++--------------------------------------------------------------------------+
+```
+
+
+
+## Doris에서 Geo 타입의 주요 용도와 사용 방법 {#common-uses-and-methods-of-geo-types-in-doris}
+### 지구상의 두 점 사이 거리 계산 {#calculating-distance-between-two-points-on-earth}
+
+베이징에서 상하이까지의 거리
+베이징(116.4074, 39.9042)과 상하이(121.4737, 31.2304)의 좌표:
+
+```sql
+select ST_DISTANCE_SPHERE(116.4074, 39.9042, 121.4737, 31.2304);
++----------------------------------------------------------+
+| ST_DISTANCE_SPHERE(116.4074, 39.9042, 121.4737, 31.2304) |
++----------------------------------------------------------+
+|                                       1067311.8461903075 |
++----------------------------------------------------------+
+```
+
+
+![대체 텍스트](/images/BeijingToShanghai.png)
+
+
+베이징에서 뉴욕까지의 거리
+베이징(116.4074, 39.9042)과 뉴욕(-74.0060, 40.7128)의 좌표:
+
+```sql
+select ST_DISTANCE_SPHERE(116.4074, 39.9042, -74.0060, 40.7128);
++----------------------------------------------------------+
+| ST_DISTANCE_SPHERE(116.4074, 39.9042, -74.0060, 40.7128) |
++----------------------------------------------------------+
+|                                       10989107.361809434 |
++----------------------------------------------------------+
+```
+
+![대체 텍스트](/images/BeijingToNewyork.png)
+
+
+### 지구 구면상의 영역 면적 계산 {#calculating-area-of-a-region-on-the-earths-sphere}
+
+뉴욕의 면적 추정
+다각형으로 뉴욕 지역의 대략적인 윤곽을 그려 면적을 계산합니다.
+
+```sql
+SELECT ST_AREA_SQUARE_KM(
+  ST_GeomFromText('POLYGON((
+      -74.2591 40.9155, 
+      -73.8726 40.9147, 
+      -73.7004 40.7506, 
+      -73.9442 40.5840, 
+      -74.0817 40.6437, 
+      -74.1502 40.6110, 
+      -74.0984 40.6550, 
+      -74.0431 40.7290, 
+      -74.0136 40.7903, 
+      -73.9352 40.8448, 
+      -74.2591 40.9155
+    ))'));
+    
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ST_AREA_SQUARE_KM(  ST_GeomFromText('POLYGON((-74.2591 40.9155, -73.8726 40.9147, -73.7004 40.7506, -73.9442 40.5840, -74.0817 40.6437,-74.1502 40.6110,-74.0984 40.6550,-74.0431 40.7290,-74.0136 40.7903,  -73.9352 40.8448, -74.2591 40.9155))'  )) |
++--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|                                                                                                                                                                                                                                      744.3806189617659 |
++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+![대체 텍스트](/images/Newyork.png)
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/JSON.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/JSON.md
new file mode 100644
index 00000000000..954a1f72ed3
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/JSON.md
@@ -0,0 +1,1230 @@
+---
+{
+    "title": "JSON | 반정형",
+    "language": "ko",
+    "description": "JSON (JavaScript Object Notation)은 사람이 읽을 수 있는 텍스트를 저장과 전송에 사용하는 개방형 표준 파일 형식이자 데이터 교환 형식입니다. ",
+    "sidebar_label": "JSON"
+}
+---
+
+# JSON {#json}
+
+## JSON 소개 {#json-introduction}
+
+JSON (JavaScript Object Notation)은 사람이 읽을 수 있는 텍스트를 사용하여 데이터를 저장하고 전송하는 개방형 표준 파일 형식이자 데이터 교환 형식입니다. 공식 명세 [RFC7159](https://datatracker.ietf.org/doc/html/rfc7159)에 따르면 JSON은 다음 기본 타입을 지원합니다.
+- Bool
+- Null
+- Number
+- String
+- Array
+- Object
+
+JSON 데이터 타입은 [JSON](https://www.rfc-editor.org/rfc/rfc8785) 데이터를 바이너리 형식으로 효율적으로 저장하며, JSON 함수를 통해 내부 필드에 접근할 수 있습니다.
+
+기본적으로 최대 1048576바이트(1MB)를 지원하며, 최대 2147483643바이트(2GB)까지 늘릴 수 있습니다. 이 값은 `string_type_length_soft_limit_bytes` 설정으로 조정할 수 있습니다.
+
+일반 STRING 타입에 JSON 문자열을 저장하는 방식과 비교하면 JSON 타입에는 두 가지 주요 장점이 있습니다.
+1. 데이터 삽입 시 JSON 형식을 검증합니다.
+2. 더 효율적인 바이너리 저장 형식을 사용하므로, `json_extract`와 같은 함수를 사용하면 `get_json_xx` 함수보다 JSON 내부 필드에 더 빠르게 접근할 수 있습니다.
+
+:::caution 참고
+1.2.x 버전에서는 JSON 타입의 이름이 JSONB였습니다. MySQL과의 호환성을 유지하기 위해 2.0.0 버전부터 JSON으로 이름이 변경되었습니다. 기존 테이블에서는 이전 이름을 계속 사용할 수 있습니다.
+:::
+
+## JSON 숫자 정밀도 문제 {#json-number-precision-issues}
+
+JSON을 사용할 때는 숫자 정밀도에 특히 주의해야 합니다.
+- 대부분의 시스템에서 Number 타입은 IEEE 754-2008의 64비트 배정밀도 부동소수점 수를 기반으로 구현됩니다(예: C++의 double 타입).
+- JSON 명세는 Number의 내부 타입을 엄격하게 정의하지 않으며, JSON 데이터는 서로 다른 시스템 간에 텍스트로 교환되므로 정밀도 손실이 발생할 수 있습니다.
+
+`{"abc": 18446744073709551616}`과 같은 JSON 문자열의 경우:
+
+```sql
+-- Conversion result in MySQL
+cast('{"abc": 18446744073709551616}' as json)
+-- Result: {"abc": 1.8446744073709552e19}
+```
+
+```javascript
+// Conversion result in JavaScript
+console.log(JSON.parse('{"abc": 18446744073709551616}'));
+// Result: {abc: 18446744073709552000}
+```
+
+시스템 간 데이터 교환 시 숫자 정밀도를 유지하려면 큰 숫자는 문자열로 저장해야 합니다. 예: `{"abc": "18446744073709551616"}`.
+
+## Doris의 JSON 타입 {#json-type-in-doris}
+
+Doris는 JSON 표준 명세를 준수하는 데이터 타입을 지원하며, 효율적인 JSONB (JSON Binary) 형식을 사용하여 데이터를 바이너리로 인코딩해 저장합니다.
+
+### 지원하는 타입 {#supported-types}
+
+Doris JSONB는 모든 표준 JSON 타입을 지원합니다. 주요 차이점은 Doris 내부 타입에 더 정확하게 매핑할 수 있도록 Number 타입을 더 세분화하여 확장했다는 점입니다.
+
+| JSON 타입 | 하위 타입 | 대응하는 Doris 타입 |
+|----------|-------|-----------------|
+| Bool | - | BOOLEAN |
+| Null | - | (직접 대응하는 타입 없음, JSON null 값을 나타냄) |
+| Number | Int8 | TINYINT |
+| | Int16 | SMALLINT |
+| | Int32 | INT |
+| | Int64 | BIGINT |
+| | Int128 | LARGEINT |
+| | Double | DOUBLE |
+| | Float | FLOAT |
+| | Decimal | DECIMAL |
+| String | - | STRING |
+| Array | - | ARRAY |
+| Object | - | STRUCT |
+
+### 주요 참고 사항: {#important-notes}
+- Null의 의미:
+  - JSON의 Null은 "빈 값"을 나타내는 유효한 값입니다. "알 수 없음" 또는 "누락됨"을 나타내는 SQL의 NULL과는 다릅니다.
+  - CAST('null' AS JSON)의 결과는 JSON null 값을 포함하는 JSONB 컬럼이며, 이 값 자체는 SQL 수준에서 NULL이 아닙니다.
+  - CAST('null' AS JSON) IS NULL은 false(0)를 반환합니다. 컬럼에 알려진 값인 JSON null이 들어 있으며, 이는 SQL NULL이 아니기 때문입니다.
+
+## 연산 및 제한 사항 {#operations-and-limitations}
+- 비교 및 산술 연산:
+  - JSONB 컬럼은 다른 데이터 타입(다른 JSONB 컬럼 포함)과 직접 비교하거나 산술 연산에 사용할 수 없습니다.
+  - 해결 방법: JSON_EXTRACT 함수로 JSONB에서 스칼라 값(INT, DOUBLE, STRING, BOOLEAN 등)을 추출한 다음, 비교나 계산을 위해 해당 Doris 기본 타입으로 변환합니다.
+- 정렬:
+  - JSONB 컬럼은 ORDER BY 연산을 지원하지 않습니다.
+- 암시적 변환:
+  - 입력 시에만 지원: JSONB 컬럼에 데이터를 입력할 때 STRING 타입은 JSONB로 암시적으로 변환될 수 있습니다(문자열 내용이 유효한 JSON 텍스트인 경우). 다른 Doris 타입은 JSONB로 암시적으로 변환될 수 없습니다.
+
+
+## JSON의 GROUP BY 및 DISTINCT 지원 {#group-by-and-distinct-support-for-json}
+
+### 예제 1: JSON 컬럼에 GROUP BY 적용 {#example-1-group-by-on-json-columns}
+```sql
+mysql> SELECT * FROM test_jsonb_groupby;
++------+---------------+
+| id   | j             |
++------+---------------+
+|    1 | {"a":1,"b":2} |
+|    2 | {"a":1,"b":3} |
+|    3 | {"a":2,"b":2} |
+|    4 | {"a":2,"b":2} |
+|    5 | {"a":1,"b":2} |
+|    6 | {"a":2,"b":2} |
++------+---------------+
+6 rows in set (0.07 sec)
+
+mysql> SELECT j, COUNT(*) FROM test_jsonb_groupby GROUP BY j;
++---------------+----------+
+| j             | COUNT(*) |
++---------------+----------+
+| {"a":1,"b":3} |        1 |
+| {"a":2,"b":2} |        3 |
+| {"a":1,"b":2} |        2 |
++---------------+----------+
+```
+
+### 예제 2: JSON 컬럼에 대한 DISTINCT 쿼리 {#example-2-distinct-query-on-json-columns}
+```sql
+mysql> SELECT DISTINCT j FROM test_jsonb_groupby;
++---------------+
+| j             |
++---------------+
+| {"a":1,"b":3} |
+| {"a":2,"b":2} |
+| {"a":1,"b":2} |
++---------------+
+```
+
+### 참고 사항 {#notes}
+1. **바이너리 비교**: JSON 비교는 바이너리를 기준으로 이루어집니다. 두 JSON 데이터가 의미상 동일하더라도 바이너리 표현이 다르면 같은 그룹으로 묶을 수 없습니다. 예를 들어:
+   ```sql
+   mysql> SELECT * FROM test_jsonb;
+   +------+------+
+   | id   | j    |
+   +------+------+
+   |    1 | 123  |
+   |    2 | 123  |
+   +------+------+
+
+   mysql> SELECT j, COUNT(*) FROM test_jsonb GROUP BY j;
+   +------+----------+
+   | j    | COUNT(*) |
+   +------+----------+
+   | 123  |        1 |
+   | 123  |        1 |
+   +------+----------+
+   ```
+
+   이는 첫 번째 `123`이 내부적으로 64비트 정수로 저장되고(`json_type`이 `bigint`를 반환), 두 번째 `123`은 더 작은 정수 타입으로 저장되어(`json_type`이 `int`를 반환하며, 이는 `bigint`보다 작은 모든 정수 타입에 적용됨) 바이너리 표현이 달라지기 때문입니다. 다음 쿼리로 타입을 확인할 수 있습니다.
+   ```sql
+   mysql> SELECT j, json_type(j, '$') FROM test_jsonb;
+   +------+------------------+
+   | j    | json_type(j, '$') |
+   +------+------------------+
+   | 123  | bigint           |
+   | 123  | int              |
+   +------+------------------+
+   ```
+
+   마찬가지로 키 순서가 다른 JSON 객체도 같은 그룹으로 묶을 수 없습니다. 예를 들어:
+   ```sql
+   mysql> SELECT * FROM test_jsonb;
+   +------+---------------+
+   | id   | j             |
+   +------+---------------+
+   |    2 | {"b":2,"a":1} |
+   |    1 | {"a":1,"b":2} |
+   +------+---------------+
+
+   mysql> SELECT j, COUNT(*) FROM test_jsonb GROUP BY j;
+   +---------------+----------+
+   | j             | COUNT(*) |
+   +---------------+----------+
+   | {"b":2,"a":1} |        1 |
+   | {"a":1,"b":2} |        1 |
+   +---------------+----------+
+   ```
+
+2. **숫자 타입의 일관성**: 숫자 타입의 차이를 무시하려면 `NORMALIZE_JSON_NUMBERS_TO_DOUBLE` 함수를 사용하여 JSON의 모든 숫자를 `DOUBLE` 타입으로 변환합니다.
+   ```sql
+   mysql> SELECT NORMALIZE_JSON_NUMBERS_TO_DOUBLE(j), COUNT(*) 
+          FROM test_jsonb 
+          GROUP BY NORMALIZE_JSON_NUMBERS_TO_DOUBLE(j);
+   +-------------------------------------+----------+
+   | NORMALIZE_JSON_NUMBERS_TO_DOUBLE(j) | COUNT(*) |
+   +-------------------------------------+----------+
+   | 123                                 |        2 |
+   +-------------------------------------+----------+
+   ```
+   텍스트 파싱을 통해 JSON 객체를 생성하는 경우(예: CAST를 사용하여 문자열을 JSON으로 변환), Doris가 저장에 적합한 숫자 타입을 자동으로 선택하므로 일반적으로 숫자 타입의 불일치는 문제가 되지 않습니다.
+
+3. **키 순서의 일관성**:
+   `SORT_JSON_OBJECT_KEYS` 함수를 사용하여 키를 정렬합니다.
+   ```sql
+   mysql> SELECT SORT_JSON_OBJECT_KEYS(j), COUNT(*) 
+          FROM test_jsonb 
+          GROUP BY SORT_JSON_OBJECT_KEYS(j);
+   +--------------------------+----------+
+   | SORT_JSON_OBJECT_KEYS(j) | COUNT(*) |
+   +--------------------------+----------+
+   | {"a":1,"b":2}            |        2 |
+   +--------------------------+----------+
+   ```
+
+   텍스트 파싱을 통해 JSON 객체를 생성하는 경우(예: CAST를 사용하여 문자열을 JSON으로 변환), Doris는 텍스트의 키 순서를 유지합니다. 따라서 JSONB 데이터가 텍스트 파싱을 통해 생성되었다면 위와 같은 그룹화 문제가 발생하지 않습니다.
+
+### 권장 사항 {#recommendations}
+JSON 데이터에서 숫자 타입이나 키 순서의 일관성을 보장할 수 없다면, `NORMALIZE_JSON_NUMBERS_TO_DOUBLE` 함수와 `SORT_JSON_OBJECT_KEYS` 함수로 데이터를 전처리한 다음 `GROUP BY` 연산을 수행하여 예상한 결과를 얻는 것이 좋습니다.
+
+### 구문 {#syntax}
+
+**정의:**
+```sql
+json_column_name JSON
+```
+
+**삽입:**
+- `INSERT INTO VALUES`를 사용할 때는 해당 형식을 따옴표로 감싼 문자열로 지정합니다. 예를 들어:
+```sql
+INSERT INTO table_name(id, json_column_name) VALUES (1, '{"k1": "100"}')
+```
+
+- STREAM LOAD에서는 해당 컬럼의 형식을 추가 따옴표가 없는 문자열로 지정합니다. 예를 들어:
+```
+12	{"k1":"v31", "k2": 300}
+13	[]
+14	[123, 456]
+```
+
+- JSON에 `'\'`가 포함된 특수 문자(예: `'\r'`, `'\t'`)가 나타나면 replace 함수를 사용하여 `"\"`를 `"\\"`로 바꿔야 합니다. 예를 들어 `"\n"`을 `"\\n"`으로 바꿔야 합니다. 
+
+
+**쿼리:**
+- JSON 컬럼 전체를 직접 선택합니다.
+```sql
+SELECT json_column_name FROM table_name;
+```
+
+- JSON 함수를 사용하여 JSON에서 특정 필드나 기타 정보를 추출합니다. 예를 들어:
+```sql
+SELECT json_extract(json_column_name, '$.k1') FROM table_name;
+```
+
+- JSON 타입은 정수, 문자열, BOOLEAN, ARRAY, MAP 타입으로 변환하거나 이들 타입에서 JSON으로 변환할 수 있습니다. 예를 들어:
+```sql
+SELECT CAST('{"k1": "100"}' AS JSON);
+SELECT CAST(json_column_name AS STRING) FROM table_name;
+SELECT CAST(json_extract(json_column_name, '$.k1') AS INT) FROM table_name;
+```
+
+:::tip
+현재 JSON 타입은 `ORDER BY` 또는 비교 연산에 사용할 수 없습니다.
+:::
+
+## JSON 입력 {#json-input}
+
+CAST를 사용하여 JSON 구문을 준수하는 문자열을 JSONB로 변환합니다.
+
+```sql
+-- Simple scalar/basic values (numeric types, bool, null, string)
+mysql> SELECT cast('5' as json);
++-------------------+
+| cast('5' as json) |
++-------------------+
+| 5                 |
++-------------------+
+
+-- Arrays with zero or more elements (elements don't need to be the same type)
+mysql> SELECT cast('[1, 2, "foo", null]' as json);
++-------------------------------------+
+| cast('[1, 2, "foo", null]' as json) |
++-------------------------------------+
+| [1,2,"foo",null]                    |
++-------------------------------------+
+
+-- Objects containing key-value pairs
+-- Note that object keys must always be quoted strings
+mysql> SELECT cast('{"bar": "baz", "balance": 7.77, "active": false}' as json);
++------------------------------------------------------------------+
+| cast('{"bar": "baz", "balance": 7.77, "active": false}' as json) |
++------------------------------------------------------------------+
+| {"bar":"baz","balance":7.77,"active":false}                      |
++------------------------------------------------------------------+
+
+-- Arrays and objects can be nested arbitrarily
+mysql> SELECT cast('{"foo": [true, "bar"], "tags": {"a": 1, "b": null}}' as json);
++---------------------------------------------------------------------+
+| cast('{"foo": [true, "bar"], "tags": {"a": 1, "b": null}}' as json) |
++---------------------------------------------------------------------+
+| {"foo":[true,"bar"],"tags":{"a":1,"b":null}}                        |
++---------------------------------------------------------------------+
+```
+
+Doris의 JSONB는 공백처럼 의미에 영향을 주지 않는 세부 사항을 보존하지 않습니다.
+
+```sql
+mysql> -- The input text and JSON output may not look the same
+mysql> SELECT cast('[1,                 2]' as json);
++----------------------------------------+
+| cast('[1,                 2]' as json) |
++----------------------------------------+
+| [1,2]                                  |
++----------------------------------------+
+```
+
+### 주요 차이점 및 참고 사항: {#key-differences-and-notes}
+- CAST(string AS JSON): JSON 구문을 준수하는 문자열을 파싱하는 데 사용합니다. Number 타입의 경우 Int8, Int16, Int32, Int64, Int128, Double 타입만 파싱하며 Decimal 타입은 파싱하지 않습니다.
+- 대부분의 다른 JSON 구현과 달리 Doris의 JSONB 타입은 최대 Int128 정밀도를 지원합니다. Int128 정밀도를 초과하는 숫자는 오버플로가 발생할 수 있습니다.
+- 입력 숫자 문자열이 12.34이면 Double로 파싱하고, 소수점이 없으면 정수로 파싱합니다(Int128 범위를 초과하면 Double로 변환되지만 정밀도 손실이 발생합니다).
+
+## to_json을 사용하여 Doris 내부 타입을 JSONB 타입으로 변환 {#using-to_json-to-convert-doris-internal-types-to-jsonb-type}
+
+```sql
+mysql> SELECT to_json(1) , to_json(3.14) , to_json("12345");
++------------+---------------+------------------+
+| to_json(1) | to_json(3.14) | to_json("12345") |
++------------+---------------+------------------+
+| 1          | 3.14          | "12345"          |
++------------+---------------+------------------+
+
+mysql> SELECT to_json(array(array(1,2,3),array(4,5,6)));
++-------------------------------------------+
+| to_json(array(array(1,2,3),array(4,5,6))) |
++-------------------------------------------+
+| [[1,2,3],[4,5,6]]                         |
++-------------------------------------------+
+
+mysql> SELECT json_extract(to_json(array(array(1,2,3),array(4,5,6))), '$.[1].[2]');
++----------------------------------------------------------------------+
+| json_extract(to_json(array(array(1,2,3),array(4,5,6))), '$.[1].[2]') |
++----------------------------------------------------------------------+
+| 6                                                                    |
++----------------------------------------------------------------------+
+
+mysql> SELECT to_json(struct(123,array(4,5,6),"789"));
++------------------------------------------+
+| to_json(struct(123,array(4,5,6),"789"))  |
++------------------------------------------+
+| {"col1":123,"col2":[4,5,6],"col3":"789"} |
++------------------------------------------+
+
+mysql> SELECT json_extract(to_json(struct(123,array(4,5,6),"789")),"$.col2");
++----------------------------------------------------------------+
+| json_extract(to_json(struct(123,array(4,5,6),"789")),"$.col2") |
++----------------------------------------------------------------+
+| [4,5,6]                                                        |
++----------------------------------------------------------------+
+```
+
+to_json은 JSONB 타입에 매핑되는 Doris 타입의 변환만 지원합니다.
+예를 들어 DECIMAL은 to_json과 함께 사용할 수 있습니다.
+하지만 DATE는 사용할 수 없으므로 먼저 STRING으로 변환한 다음 to_json을 사용해야 합니다.
+
+## JSONB 출력 {#jsonb-output}
+
+다른 시스템과 데이터를 교환하기 위해 일반 텍스트로 변환할 때 Doris의 JSONB 타입은 유효한 JSON 텍스트를 생성합니다.
+
+1. Null 값:
+   - null로 출력(따옴표 없음)
+2. 불리언 값:
+   - true → true 출력
+   - false → false 출력
+3. 숫자 타입:
+   - 모든 숫자 값을 그대로 출력
+   - 예: 5 → 5 출력, 3.14 → 3.14 출력
+4. 문자열:
+   - 큰따옴표로 감싸서 출력: "<content>"
+   - 특수 문자는 이스케이프 처리:
+     - " → \"
+     - \ → \\
+     - / → \/
+     - 백스페이스 → \b
+     - 폼 피드 → \f
+     - 줄 바꿈 → \n
+     - 캐리지 리턴 → \r
+     - 탭 → \t
+   - 기타 제어 문자(ASCII < 32)는 Unicode 이스케이프 시퀀스로 변환: \uXXXX
+5. 객체:
+   - 형식: {<key-value pairs list>}
+   - 키-값 쌍 형식: "<key>": <value>
+   - 여러 키-값 쌍은 쉼표로 구분
+6. 배열:
+   - 형식: [<element list>]
+   - 여러 요소는 쉼표로 구분
+7. 중첩 구조 처리:
+   - 객체와 배열은 중첩 깊이에 제한이 없음
+   - 각 중첩 수준은 동일한 규칙에 따라 재귀적으로 처리
+
+## 숫자 정밀도 문제 {#number-precision-issues}
+
+to_json을 사용하여 Doris 내부 타입을 JSONB로 변환할 때는 정밀도 손실이 발생하지 않습니다.
+Doris 내부 JSON 함수를 사용할 때도 반환값이 JSONB 타입이면 정밀도 손실이 발생하지 않습니다.
+하지만 Doris JSONB를 일반 텍스트로 변환한 다음 다시 JSONB로 변환하면 정밀도 손실이 발생할 수 있습니다.
+
+예: Doris JSON 타입 객체
+```
+Object{
+    "a": (Decimal 18446744073709551616.123)
+}
+```
+
+일반 텍스트로 변환한 결과:
+```
+{"a": 18446744073709551616.123}
+```
+
+일반 텍스트를 다시 Doris JSON 타입으로 변환한 결과:
+```
+Object{
+    "a": (Double 18446744073709552000)  // precision loss
+}
+```
+
+## 설정 및 제한 사항 {#configuration-and-limitations}
+- JSON은 기본적으로 1,048,576바이트(1 MB)를 지원합니다.
+- 크기 제한은 BE 설정 매개변수 string_type_length_soft_limit_bytes로 조정할 수 있습니다.
+- 최대 2,147,483,643바이트(약 2 GB)까지 조정할 수 있습니다.
+- Doris JSON 타입 객체에서 키 길이는 255바이트를 초과할 수 없습니다.
+
+## 사용 예제 {#usage-example}
+테이블 생성, 데이터 적재, 쿼리를 포함한 JSON 데이터 타입 튜토리얼입니다.
+
+#### 데이터베이스 및 테이블 생성 {#create-database-and-table}
+
+```
+CREATE DATABASE testdb;
+
+USE testdb;
+
+CREATE TABLE test_json (
+  id INT,
+  j JSON
+)
+DUPLICATE KEY(id)
+DISTRIBUTED BY HASH(id) BUCKETS 10
+PROPERTIES("replication_num" = "1");
+```
+
+#### 데이터 적재 {#load-data}
+
+##### Stream Load용 test_json.csv 테스트 데이터 {#stream-load-test_jsoncsv-test-data}
+
+- 컬럼은 2개이며, 1번째 컬럼은 id이고 2번째 컬럼은 JSON 문자열입니다.
+- 총 25개 행 중 처음 18개 행은 유효한 JSON이고 마지막 7개 행은 유효하지 않습니다.
+
+
+```
+1	\N
+2	null
+3	true
+4	false
+5	100
+6	10000
+7	1000000000
+8	1152921504606846976
+9	6.18
+10	"abcd"
+11	{}
+12	{"k1":"v31", "k2": 300}
+13	[]
+14	[123, 456]
+15	["abc", "def"]
+16	[null, true, false, 100, 6.18, "abc"]
+17	[{"k1":"v41", "k2": 400}, 1, "a", 3.14]
+18	{"k1":"v31", "k2": 300, "a1": [{"k1":"v41", "k2": 400}, 1, "a", 3.14]}
+19	''
+20	'abc'
+21	abc
+22	100x
+23	6.a8
+24	{x
+25	[123, abc]
+```
+
+- 행의 28%가 유효하지 않으므로 기본 설정으로 Stream Load를 수행하면 "too many filtered rows" 오류 메시지와 함께 실패합니다.
+
+```
+curl --location-trusted -u root: -T test_json.csv http://127.0.0.1:8840/api/testdb/test_json/_stream_load
+{
+    "TxnId": 12019,
+    "Label": "744d9821-9c9f-43dc-bf3b-7ab048f14e32",
+    "TwoPhaseCommit": "false",
+    "Status": "Fail",
+    "Message": "too many filtered rows",
+    "NumberTotalRows": 25,
+    "NumberLoadedRows": 18,
+    "NumberFilteredRows": 7,
+    "NumberUnselectedRows": 0,
+    "LoadBytes": 380,
+    "LoadTimeMs": 48,
+    "BeginTxnTimeMs": 0,
+    "StreamLoadPutTimeMs": 1,
+    "ReadDataTimeMs": 0,
+    "WriteDataTimeMs": 45,
+    "CommitAndPublishTimeMs": 0,
+    "ErrorURL": "http://172.21.0.5:8840/api/_load_error_log?file=__shard_2/error_log_insert_stmt_95435c4bf5f156df-426735082a9296af_95435c4bf5f156df_426735082a9296af"
+}
+```
+
+- 헤더 설정을 'max_filter_ratio: 0.3'으로 지정하면 Stream Load가 성공합니다.
+```
+curl --location-trusted -u root: -H 'max_filter_ratio: 0.3' -T test_json.csv http://127.0.0.1:8840/api/testdb/test_json/_stream_load
+{
+    "TxnId": 12017,
+    "Label": "f37a50c1-43e9-4f4e-a159-a3db6abe2579",
+    "TwoPhaseCommit": "false",
+    "Status": "Success",
+    "Message": "OK",
+    "NumberTotalRows": 25,
+    "NumberLoadedRows": 18,
+    "NumberFilteredRows": 7,
+    "NumberUnselectedRows": 0,
+    "LoadBytes": 380,
+    "LoadTimeMs": 68,
+    "BeginTxnTimeMs": 0,
+    "StreamLoadPutTimeMs": 2,
+    "ReadDataTimeMs": 0,
+    "WriteDataTimeMs": 45,
+    "CommitAndPublishTimeMs": 19,
+    "ErrorURL": "http://172.21.0.5:8840/api/_load_error_log?file=__shard_0/error_log_insert_stmt_a1463f98a7b15caf-c79399b920f5bfa3_a1463f98a7b15caf_c79399b920f5bfa3"
+}
+```
+
+- SELECT를 사용하여 Stream Load로 적재한 데이터를 확인합니다. JSON 타입 컬럼은 일반 JSON 문자열로 표시됩니다.
+
+```
+mysql> SELECT * FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+
+| id   | j                                                             |
++------+---------------------------------------------------------------+
+|    1 |                                                          NULL |
+|    2 |                                                          null |
+|    3 |                                                          true |
+|    4 |                                                         false |
+|    5 |                                                           100 |
+|    6 |                                                         10000 |
+|    7 |                                                    1000000000 |
+|    8 |                                           1152921504606846976 |
+|    9 |                                                          6.18 |
+|   10 |                                                        "abcd" |
+|   11 |                                                            {} |
+|   12 |                                         {"k1":"v31","k2":300} |
+|   13 |                                                            [] |
+|   14 |                                                     [123,456] |
+|   15 |                                                 ["abc","def"] |
+|   16 |                              [null,true,false,100,6.18,"abc"] |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |
++------+---------------------------------------------------------------+
+18 rows in set (0.03 sec)
+
+```
+
+##### insert into를 사용한 데이터 쓰기 {#write-data-using-insert-into}
+
+- 전체 행 수는 18개에서 19개로 늘어나며, 이는 1개 행을 삽입한 결과입니다.
+```
+mysql> INSERT INTO test_json VALUES(26, '{"k1":"v1", "k2": 200}');
+Query OK, 1 row affected (0.09 sec)
+{'label':'insert_4ece6769d1b42fd_ac9f25b3b8f3dc02', 'status':'VISIBLE', 'txnId':'12016'}
+
+mysql> SELECT * FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+
+| id   | j                                                             |
++------+---------------------------------------------------------------+
+|    1 |                                                          NULL |
+|    2 |                                                          null |
+|    3 |                                                          true |
+|    4 |                                                         false |
+|    5 |                                                           100 |
+|    6 |                                                         10000 |
+|    7 |                                                    1000000000 |
+|    8 |                                           1152921504606846976 |
+|    9 |                                                          6.18 |
+|   10 |                                                        "abcd" |
+|   11 |                                                            {} |
+|   12 |                                         {"k1":"v31","k2":300} |
+|   13 |                                                            [] |
+|   14 |                                                     [123,456] |
+|   15 |                                                 ["abc","def"] |
+|   16 |                              [null,true,false,100,6.18,"abc"] |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |
+|   26 |                                          {"k1":"v1","k2":200} |
++------+---------------------------------------------------------------+
+19 rows in set (0.03 sec)
+
+```
+
+#### 쿼리 {#query}
+
+##### json_extract 함수로 JSON에서 필드 추출 {#extract-some-filed-from-json-by-json_extract-functions}
+
+1. JSON 전체를 추출합니다. '$'는 JSON 경로에서 루트를 나타냅니다.
+```
++------+---------------------------------------------------------------+---------------------------------------------------------------+
+| id   | j                                                             | json_extract(`j`, '$')                                       |
++------+---------------------------------------------------------------+---------------------------------------------------------------+
+|    1 |                                                          NULL |                                                          NULL |
+|    2 |                                                          null |                                                          null |
+|    3 |                                                          true |                                                          true |
+|    4 |                                                         false |                                                         false |
+|    5 |                                                           100 |                                                           100 |
+|    6 |                                                         10000 |                                                         10000 |
+|    7 |                                                    1000000000 |                                                    1000000000 |
+|    8 |                                           1152921504606846976 |                                           1152921504606846976 |
+|    9 |                                                          6.18 |                                                          6.18 |
+|   10 |                                                        "abcd" |                                                        "abcd" |
+|   11 |                                                            {} |                                                            {} |
+|   12 |                                         {"k1":"v31","k2":300} |                                         {"k1":"v31","k2":300} |
+|   13 |                                                            [] |                                                            [] |
+|   14 |                                                     [123,456] |                                                     [123,456] |
+|   15 |                                                 ["abc","def"] |                                                 ["abc","def"] |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                              [null,true,false,100,6.18,"abc"] |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                            [{"k1":"v41","k2":400},1,"a",3.14] |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |
+|   26 |                                          {"k1":"v1","k2":200} |                                          {"k1":"v1","k2":200} |
++------+---------------------------------------------------------------+---------------------------------------------------------------+
+19 rows in set (0.03 sec)
+```
+
+1. k1 필드를 추출하며, 필드가 없으면 NULL을 반환합니다.
+```
+mysql> SELECT id, j, json_extract(j, '$.k1') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+----------------------------+
+| id   | j                                                             | json_extract(`j`, '$.k1') |
++------+---------------------------------------------------------------+----------------------------+
+|    1 |                                                          NULL |                       NULL |
+|    2 |                                                          null |                       NULL |
+|    3 |                                                          true |                       NULL |
+|    4 |                                                         false |                       NULL |
+|    5 |                                                           100 |                       NULL |
+|    6 |                                                         10000 |                       NULL |
+|    7 |                                                    1000000000 |                       NULL |
+|    8 |                                           1152921504606846976 |                       NULL |
+|    9 |                                                          6.18 |                       NULL |
+|   10 |                                                        "abcd" |                       NULL |
+|   11 |                                                            {} |                       NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                      "v31" |
+|   13 |                                                            [] |                       NULL |
+|   14 |                                                     [123,456] |                       NULL |
+|   15 |                                                 ["abc","def"] |                       NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                       NULL |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                       NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                      "v31" |
+|   26 |                                          {"k1":"v1","k2":200} |                       "v1" |
++------+---------------------------------------------------------------+----------------------------+
+19 rows in set (0.03 sec)
+```
+
+1. 최상위 배열에서 인덱스 0의 요소를 추출합니다.
+```
+mysql> SELECT id, j, json_extract(j, '$[0]') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+----------------------------+
+| id   | j                                                             | json_extract(`j`, '$[0]') |
++------+---------------------------------------------------------------+----------------------------+
+|    1 |                                                          NULL |                       NULL |
+|    2 |                                                          null |                       NULL |
+|    3 |                                                          true |                       NULL |
+|    4 |                                                         false |                       NULL |
+|    5 |                                                           100 |                       NULL |
+|    6 |                                                         10000 |                       NULL |
+|    7 |                                                    1000000000 |                       NULL |
+|    8 |                                           1152921504606846976 |                       NULL |
+|    9 |                                                          6.18 |                       NULL |
+|   10 |                                                        "abcd" |                       NULL |
+|   11 |                                                            {} |                       NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                       NULL |
+|   13 |                                                            [] |                       NULL |
+|   14 |                                                     [123,456] |                        123 |
+|   15 |                                                 ["abc","def"] |                      "abc" |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                       null |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |      {"k1":"v41","k2":400} |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                       NULL |
+|   26 |                                          {"k1":"v1","k2":200} |                       NULL |
++------+---------------------------------------------------------------+----------------------------+
+19 rows in set (0.03 sec)
+```
+
+1. 이름이 a1인 JSON 배열 전체를 추출합니다.
+```
+mysql> SELECT id, j, json_extract(j, '$.a1') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+------------------------------------+
+| id   | j                                                             | json_extract(`j`, '$.a1')         |
++------+---------------------------------------------------------------+------------------------------------+
+|    1 |                                                          NULL |                               NULL |
+|    2 |                                                          null |                               NULL |
+|    3 |                                                          true |                               NULL |
+|    4 |                                                         false |                               NULL |
+|    5 |                                                           100 |                               NULL |
+|    6 |                                                         10000 |                               NULL |
+|    7 |                                                    1000000000 |                               NULL |
+|    8 |                                           1152921504606846976 |                               NULL |
+|    9 |                                                          6.18 |                               NULL |
+|   10 |                                                        "abcd" |                               NULL |
+|   11 |                                                            {} |                               NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                               NULL |
+|   13 |                                                            [] |                               NULL |
+|   14 |                                                     [123,456] |                               NULL |
+|   15 |                                                 ["abc","def"] |                               NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                               NULL |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                               NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} | [{"k1":"v41","k2":400},1,"a",3.14] |
+|   26 |                                          {"k1":"v1","k2":200} |                               NULL |
++------+---------------------------------------------------------------+------------------------------------+
+19 rows in set (0.02 sec)
+```
+
+1. 배열에 포함된 객체에서 중첩 필드를 추출합니다.
+```
+mysql> SELECT id, j, json_extract(j, '$.a1[0]'), json_extract(j, '$.a1[0].k1') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+-------------------------------+----------------------------------+
+| id   | j                                                             | json_extract(`j`, '$.a1[0]') | json_extract(`j`, '$.a1[0].k1') |
++------+---------------------------------------------------------------+-------------------------------+----------------------------------+
+|    1 |                                                          NULL |                          NULL |                             NULL |
+|    2 |                                                          null |                          NULL |                             NULL |
+|    3 |                                                          true |                          NULL |                             NULL |
+|    4 |                                                         false |                          NULL |                             NULL |
+|    5 |                                                           100 |                          NULL |                             NULL |
+|    6 |                                                         10000 |                          NULL |                             NULL |
+|    7 |                                                    1000000000 |                          NULL |                             NULL |
+|    8 |                                           1152921504606846976 |                          NULL |                             NULL |
+|    9 |                                                          6.18 |                          NULL |                             NULL |
+|   10 |                                                        "abcd" |                          NULL |                             NULL |
+|   11 |                                                            {} |                          NULL |                             NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                          NULL |                             NULL |
+|   13 |                                                            [] |                          NULL |                             NULL |
+|   14 |                                                     [123,456] |                          NULL |                             NULL |
+|   15 |                                                 ["abc","def"] |                          NULL |                             NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                          NULL |                             NULL |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                          NULL |                             NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |         {"k1":"v41","k2":400} |                            "v41" |
+|   26 |                                          {"k1":"v1","k2":200} |                          NULL |                             NULL |
++------+---------------------------------------------------------------+-------------------------------+----------------------------------+
+19 rows in set (0.02 sec)
+
+```
+
+1. 특정 데이터 타입으로 필드를 추출합니다.
+- json_extract_string은 필드를 string 타입으로 추출하며, 필드가 string 타입이 아니면 문자열로 변환합니다.
+```
+mysql> SELECT id, j, json_extract_string(j, '$') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+---------------------------------------------------------------+
+| id   | j                                                             | json_extract_string(`j`, '$')                                |
++------+---------------------------------------------------------------+---------------------------------------------------------------+
+|    1 | NULL                                                          | NULL                                                          |
+|    2 | null                                                          | null                                                          |
+|    3 | true                                                          | true                                                          |
+|    4 | false                                                         | false                                                         |
+|    5 | 100                                                           | 100                                                           |
+|    6 | 10000                                                         | 10000                                                         |
+|    7 | 1000000000                                                    | 1000000000                                                    |
+|    8 | 1152921504606846976                                           | 1152921504606846976                                           |
+|    9 | 6.18                                                          | 6.18                                                          |
+|   10 | "abcd"                                                        | abcd                                                          |
+|   11 | {}                                                            | {}                                                            |
+|   12 | {"k1":"v31","k2":300}                                         | {"k1":"v31","k2":300}                                         |
+|   13 | []                                                            | []                                                            |
+|   14 | [123,456]                                                     | [123,456]                                                     |
+|   15 | ["abc","def"]                                                 | ["abc","def"]                                                 |
+|   16 | [null,true,false,100,6.18,"abc"]                              | [null,true,false,100,6.18,"abc"]                              |
+|   17 | [{"k1":"v41","k2":400},1,"a",3.14]                            | [{"k1":"v41","k2":400},1,"a",3.14]                            |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |
+|   26 | {"k1":"v1","k2":200}                                          | {"k1":"v1","k2":200}                                          |
++------+---------------------------------------------------------------+---------------------------------------------------------------+
+19 rows in set (0.02 sec)
+
+mysql> SELECT id, j, json_extract_string(j, '$.k1') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+-----------------------------------+
+| id   | j                                                             | json_extract_string(`j`, '$.k1') |
++------+---------------------------------------------------------------+-----------------------------------+
+|    1 |                                                          NULL | NULL                              |
+|    2 |                                                          null | NULL                              |
+|    3 |                                                          true | NULL                              |
+|    4 |                                                         false | NULL                              |
+|    5 |                                                           100 | NULL                              |
+|    6 |                                                         10000 | NULL                              |
+|    7 |                                                    1000000000 | NULL                              |
+|    8 |                                           1152921504606846976 | NULL                              |
+|    9 |                                                          6.18 | NULL                              |
+|   10 |                                                        "abcd" | NULL                              |
+|   11 |                                                            {} | NULL                              |
+|   12 |                                         {"k1":"v31","k2":300} | v31                               |
+|   13 |                                                            [] | NULL                              |
+|   14 |                                                     [123,456] | NULL                              |
+|   15 |                                                 ["abc","def"] | NULL                              |
+|   16 |                              [null,true,false,100,6.18,"abc"] | NULL                              |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] | NULL                              |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} | v31                               |
+|   26 |                                          {"k1":"v1","k2":200} | v1                                |
++------+---------------------------------------------------------------+-----------------------------------+
+19 rows in set (0.03 sec)
+
+```
+
+- json_extract_int는 필드를 int 타입으로 추출하며, 필드가 int 타입이 아니면 NULL을 반환합니다.
+```
+mysql> SELECT id, j, json_extract_int(j, '$') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+-----------------------------+
+| id   | j                                                             | json_extract_int(`j`, '$') |
++------+---------------------------------------------------------------+-----------------------------+
+|    1 |                                                          NULL |                        NULL |
+|    2 |                                                          null |                        NULL |
+|    3 |                                                          true |                        NULL |
+|    4 |                                                         false |                        NULL |
+|    5 |                                                           100 |                         100 |
+|    6 |                                                         10000 |                       10000 |
+|    7 |                                                    1000000000 |                  1000000000 |
+|    8 |                                           1152921504606846976 |                        NULL |
+|    9 |                                                          6.18 |                        NULL |
+|   10 |                                                        "abcd" |                        NULL |
+|   11 |                                                            {} |                        NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                        NULL |
+|   13 |                                                            [] |                        NULL |
+|   14 |                                                     [123,456] |                        NULL |
+|   15 |                                                 ["abc","def"] |                        NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                        NULL |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                        NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                        NULL |
+|   26 |                                          {"k1":"v1","k2":200} |                        NULL |
++------+---------------------------------------------------------------+-----------------------------+
+19 rows in set (0.02 sec)
+
+mysql> SELECT id, j, json_extract_int(j, '$.k2') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+--------------------------------+
+| id   | j                                                             | json_extract_int(`j`, '$.k2') |
++------+---------------------------------------------------------------+--------------------------------+
+|    1 |                                                          NULL |                           NULL |
+|    2 |                                                          null |                           NULL |
+|    3 |                                                          true |                           NULL |
+|    4 |                                                         false |                           NULL |
+|    5 |                                                           100 |                           NULL |
+|    6 |                                                         10000 |                           NULL |
+|    7 |                                                    1000000000 |                           NULL |
+|    8 |                                           1152921504606846976 |                           NULL |
+|    9 |                                                          6.18 |                           NULL |
+|   10 |                                                        "abcd" |                           NULL |
+|   11 |                                                            {} |                           NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                            300 |
+|   13 |                                                            [] |                           NULL |
+|   14 |                                                     [123,456] |                           NULL |
+|   15 |                                                 ["abc","def"] |                           NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                           NULL |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                           NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                            300 |
+|   26 |                                          {"k1":"v1","k2":200} |                            200 |
++------+---------------------------------------------------------------+--------------------------------+
+19 rows in set (0.03 sec)
+```
+
+- json_extract_bigint는 필드를 bigint 타입으로 추출하며, 필드가 bigint 타입이 아니면 NULL을 반환합니다.
+```
+mysql> SELECT id, j, json_extract_bigint(j, '$') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+--------------------------------+
+| id   | j                                                             | json_extract_bigint(`j`, '$') |
++------+---------------------------------------------------------------+--------------------------------+
+|    1 |                                                          NULL |                           NULL |
+|    2 |                                                          null |                           NULL |
+|    3 |                                                          true |                           NULL |
+|    4 |                                                         false |                           NULL |
+|    5 |                                                           100 |                            100 |
+|    6 |                                                         10000 |                          10000 |
+|    7 |                                                    1000000000 |                     1000000000 |
+|    8 |                                           1152921504606846976 |            1152921504606846976 |
+|    9 |                                                          6.18 |                           NULL |
+|   10 |                                                        "abcd" |                           NULL |
+|   11 |                                                            {} |                           NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                           NULL |
+|   13 |                                                            [] |                           NULL |
+|   14 |                                                     [123,456] |                           NULL |
+|   15 |                                                 ["abc","def"] |                           NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                           NULL |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                           NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                           NULL |
+|   26 |                                          {"k1":"v1","k2":200} |                           NULL |
++------+---------------------------------------------------------------+--------------------------------+
+19 rows in set (0.03 sec)
+
+mysql> SELECT id, j, json_extract_bigint(j, '$.k2') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+-----------------------------------+
+| id   | j                                                             | json_extract_bigint(`j`, '$.k2') |
++------+---------------------------------------------------------------+-----------------------------------+
+|    1 |                                                          NULL |                              NULL |
+|    2 |                                                          null |                              NULL |
+|    3 |                                                          true |                              NULL |
+|    4 |                                                         false |                              NULL |
+|    5 |                                                           100 |                              NULL |
+|    6 |                                                         10000 |                              NULL |
+|    7 |                                                    1000000000 |                              NULL |
+|    8 |                                           1152921504606846976 |                              NULL |
+|    9 |                                                          6.18 |                              NULL |
+|   10 |                                                        "abcd" |                              NULL |
+|   11 |                                                            {} |                              NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                               300 |
+|   13 |                                                            [] |                              NULL |
+|   14 |                                                     [123,456] |                              NULL |
+|   15 |                                                 ["abc","def"] |                              NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                              NULL |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                              NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                               300 |
+|   26 |                                          {"k1":"v1","k2":200} |                               200 |
++------+---------------------------------------------------------------+-----------------------------------+
+19 rows in set (0.02 sec)
+
+```
+
+- json_extract_double은 필드를 double 타입으로 추출하며, 필드가 double 타입이 아니면 NULL을 반환합니다.
+```
+mysql> SELECT id, j, json_extract_double(j, '$') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+--------------------------------+
+| id   | j                                                             | json_extract_double(`j`, '$') |
++------+---------------------------------------------------------------+--------------------------------+
+|    1 |                                                          NULL |                           NULL |
+|    2 |                                                          null |                           NULL |
+|    3 |                                                          true |                           NULL |
+|    4 |                                                         false |                           NULL |
+|    5 |                                                           100 |                            100 |
+|    6 |                                                         10000 |                          10000 |
+|    7 |                                                    1000000000 |                     1000000000 |
+|    8 |                                           1152921504606846976 |          1.152921504606847e+18 |
+|    9 |                                                          6.18 |                           6.18 |
+|   10 |                                                        "abcd" |                           NULL |
+|   11 |                                                            {} |                           NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                           NULL |
+|   13 |                                                            [] |                           NULL |
+|   14 |                                                     [123,456] |                           NULL |
+|   15 |                                                 ["abc","def"] |                           NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                           NULL |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                           NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                           NULL |
+|   26 |                                          {"k1":"v1","k2":200} |                           NULL |
++------+---------------------------------------------------------------+--------------------------------+
+19 rows in set (0.02 sec)
+
+mysql> SELECT id, j, json_extract_double(j, '$.k2') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+-----------------------------------+
+| id   | j                                                             | json_extract_double(`j`, '$.k2') |
++------+---------------------------------------------------------------+-----------------------------------+
+|    1 |                                                          NULL |                              NULL |
+|    2 |                                                          null |                              NULL |
+|    3 |                                                          true |                              NULL |
+|    4 |                                                         false |                              NULL |
+|    5 |                                                           100 |                              NULL |
+|    6 |                                                         10000 |                              NULL |
+|    7 |                                                    1000000000 |                              NULL |
+|    8 |                                           1152921504606846976 |                              NULL |
+|    9 |                                                          6.18 |                              NULL |
+|   10 |                                                        "abcd" |                              NULL |
+|   11 |                                                            {} |                              NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                               300 |
+|   13 |                                                            [] |                              NULL |
+|   14 |                                                     [123,456] |                              NULL |
+|   15 |                                                 ["abc","def"] |                              NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                              NULL |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                              NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                               300 |
+|   26 |                                          {"k1":"v1","k2":200} |                               200 |
++------+---------------------------------------------------------------+-----------------------------------+
+19 rows in set (0.03 sec)
+```
+
+- json_extract_bool은 필드를 boolean 타입으로 추출하며, 필드가 boolean 타입이 아니면 NULL을 반환합니다.
+```
+mysql> SELECT id, j, json_extract_bool(j, '$') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+------------------------------+
+| id   | j                                                             | json_extract_bool(`j`, '$') |
++------+---------------------------------------------------------------+------------------------------+
+|    1 |                                                          NULL |                         NULL |
+|    2 |                                                          null |                         NULL |
+|    3 |                                                          true |                            1 |
+|    4 |                                                         false |                            0 |
+|    5 |                                                           100 |                         NULL |
+|    6 |                                                         10000 |                         NULL |
+|    7 |                                                    1000000000 |                         NULL |
+|    8 |                                           1152921504606846976 |                         NULL |
+|    9 |                                                          6.18 |                         NULL |
+|   10 |                                                        "abcd" |                         NULL |
+|   11 |                                                            {} |                         NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                         NULL |
+|   13 |                                                            [] |                         NULL |
+|   14 |                                                     [123,456] |                         NULL |
+|   15 |                                                 ["abc","def"] |                         NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                         NULL |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                         NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                         NULL |
+|   26 |                                          {"k1":"v1","k2":200} |                         NULL |
++------+---------------------------------------------------------------+------------------------------+
+19 rows in set (0.01 sec)
+
+mysql> SELECT id, j, json_extract_bool(j, '$[1]') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+---------------------------------+
+| id   | j                                                             | json_extract_bool(`j`, '$[1]') |
++------+---------------------------------------------------------------+---------------------------------+
+|    1 |                                                          NULL |                            NULL |
+|    2 |                                                          null |                            NULL |
+|    3 |                                                          true |                            NULL |
+|    4 |                                                         false |                            NULL |
+|    5 |                                                           100 |                            NULL |
+|    6 |                                                         10000 |                            NULL |
+|    7 |                                                    1000000000 |                            NULL |
+|    8 |                                           1152921504606846976 |                            NULL |
+|    9 |                                                          6.18 |                            NULL |
+|   10 |                                                        "abcd" |                            NULL |
+|   11 |                                                            {} |                            NULL |
+|   12 |                                         {"k1":"v31","k2":300} |                            NULL |
+|   13 |                                                            [] |                            NULL |
+|   14 |                                                     [123,456] |                            NULL |
+|   15 |                                                 ["abc","def"] |                            NULL |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                               1 |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                            NULL |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                            NULL |
+|   26 |                                          {"k1":"v1","k2":200} |                            NULL |
++------+---------------------------------------------------------------+---------------------------------+
+19 rows in set (0.01 sec)
+```
+
+- json_extract_isnull은 필드가 JSON null 타입인지 확인하며, 필드가 JSON null이면 1을, 그렇지 않으면 0을 반환합니다.
+- JSON null은 SQL NULL과 다릅니다. SQL NULL은 필드에 값이 없음을 나타내지만, JSON null은 필드에 특수 값인 null이 있음을 나타냅니다.
+```
+mysql> SELECT id, j, json_extract_isnull(j, '$') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+--------------------------------+
+| id   | j                                                             | json_extract_isnull(`j`, '$') |
++------+---------------------------------------------------------------+--------------------------------+
+|    1 |                                                          NULL |                           NULL |
+|    2 |                                                          null |                              1 |
+|    3 |                                                          true |                              0 |
+|    4 |                                                         false |                              0 |
+|    5 |                                                           100 |                              0 |
+|    6 |                                                         10000 |                              0 |
+|    7 |                                                    1000000000 |                              0 |
+|    8 |                                           1152921504606846976 |                              0 |
+|    9 |                                                          6.18 |                              0 |
+|   10 |                                                        "abcd" |                              0 |
+|   11 |                                                            {} |                              0 |
+|   12 |                                         {"k1":"v31","k2":300} |                              0 |
+|   13 |                                                            [] |                              0 |
+|   14 |                                                     [123,456] |                              0 |
+|   15 |                                                 ["abc","def"] |                              0 |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                              0 |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                              0 |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                              0 |
+|   26 |                                          {"k1":"v1","k2":200} |                              0 |
++------+---------------------------------------------------------------+--------------------------------+
+19 rows in set (0.03 sec)
+
+```
+
+##### json_exists_path로 JSON에 필드가 있는지 확인 {#check-if-a-field-is-existed-in-json-by-json_exists_path}
+
+```
+mysql> SELECT id, j, json_exists_path(j, '$') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+-----------------------------+
+| id   | j                                                             | json_exists_path(`j`, '$') |
++------+---------------------------------------------------------------+-----------------------------+
+|    1 |                                                          NULL |                        NULL |
+|    2 |                                                          null |                           1 |
+|    3 |                                                          true |                           1 |
+|    4 |                                                         false |                           1 |
+|    5 |                                                           100 |                           1 |
+|    6 |                                                         10000 |                           1 |
+|    7 |                                                    1000000000 |                           1 |
+|    8 |                                           1152921504606846976 |                           1 |
+|    9 |                                                          6.18 |                           1 |
+|   10 |                                                        "abcd" |                           1 |
+|   11 |                                                            {} |                           1 |
+|   12 |                                         {"k1":"v31","k2":300} |                           1 |
+|   13 |                                                            [] |                           1 |
+|   14 |                                                     [123,456] |                           1 |
+|   15 |                                                 ["abc","def"] |                           1 |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                           1 |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                           1 |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                           1 |
+|   26 |                                          {"k1":"v1","k2":200} |                           1 |
++------+---------------------------------------------------------------+-----------------------------+
+19 rows in set (0.02 sec)
+
+mysql> SELECT id, j, json_exists_path(j, '$.k1') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+--------------------------------+
+| id   | j                                                             | json_exists_path(`j`, '$.k1') |
++------+---------------------------------------------------------------+--------------------------------+
+|    1 |                                                          NULL |                           NULL |
+|    2 |                                                          null |                              0 |
+|    3 |                                                          true |                              0 |
+|    4 |                                                         false |                              0 |
+|    5 |                                                           100 |                              0 |
+|    6 |                                                         10000 |                              0 |
+|    7 |                                                    1000000000 |                              0 |
+|    8 |                                           1152921504606846976 |                              0 |
+|    9 |                                                          6.18 |                              0 |
+|   10 |                                                        "abcd" |                              0 |
+|   11 |                                                            {} |                              0 |
+|   12 |                                         {"k1":"v31","k2":300} |                              1 |
+|   13 |                                                            [] |                              0 |
+|   14 |                                                     [123,456] |                              0 |
+|   15 |                                                 ["abc","def"] |                              0 |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                              0 |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                              0 |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                              1 |
+|   26 |                                          {"k1":"v1","k2":200} |                              1 |
++------+---------------------------------------------------------------+--------------------------------+
+19 rows in set (0.03 sec)
+
+mysql> SELECT id, j, json_exists_path(j, '$[2]') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+--------------------------------+
+| id   | j                                                             | json_exists_path(`j`, '$[2]') |
++------+---------------------------------------------------------------+--------------------------------+
+|    1 |                                                          NULL |                           NULL |
+|    2 |                                                          null |                              0 |
+|    3 |                                                          true |                              0 |
+|    4 |                                                         false |                              0 |
+|    5 |                                                           100 |                              0 |
+|    6 |                                                         10000 |                              0 |
+|    7 |                                                    1000000000 |                              0 |
+|    8 |                                           1152921504606846976 |                              0 |
+|    9 |                                                          6.18 |                              0 |
+|   10 |                                                        "abcd" |                              0 |
+|   11 |                                                            {} |                              0 |
+|   12 |                                         {"k1":"v31","k2":300} |                              0 |
+|   13 |                                                            [] |                              0 |
+|   14 |                                                     [123,456] |                              0 |
+|   15 |                                                 ["abc","def"] |                              0 |
+|   16 |                              [null,true,false,100,6.18,"abc"] |                              1 |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] |                              1 |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} |                              0 |
+|   26 |                                          {"k1":"v1","k2":200} |                              0 |
++------+---------------------------------------------------------------+--------------------------------+
+19 rows in set (0.02 sec)
+
+
+```
+
+##### json_type으로 JSON 필드의 데이터 타입 확인 {#get-the-datatype-of-a-field-in-json-by-json_type}
+
+- JSON 경로로 지정한 필드의 데이터 타입을 반환하며, 필드가 없으면 NULL을 반환합니다.
+```
+mysql> SELECT id, j, json_type(j, '$') FROM test_json ORDER BY id;
++------+---------------------------------------------------------------+----------------------+
+| id   | j                                                             | json_type(`j`, '$') |
++------+---------------------------------------------------------------+----------------------+
+|    1 |                                                          NULL | NULL                 |
+|    2 |                                                          null | null                 |
+|    3 |                                                          true | bool                 |
+|    4 |                                                         false | bool                 |
+|    5 |                                                           100 | int                  |
+|    6 |                                                         10000 | int                  |
+|    7 |                                                    1000000000 | int                  |
+|    8 |                                           1152921504606846976 | bigint               |
+|    9 |                                                          6.18 | double               |
+|   10 |                                                        "abcd" | string               |
+|   11 |                                                            {} | object               |
+|   12 |                                         {"k1":"v31","k2":300} | object               |
+|   13 |                                                            [] | array                |
+|   14 |                                                     [123,456] | array                |
+|   15 |                                                 ["abc","def"] | array                |
+|   16 |                              [null,true,false,100,6.18,"abc"] | array                |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] | array                |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} | object               |
+|   26 |                                          {"k1":"v1","k2":200} | object               |
++------+---------------------------------------------------------------+----------------------+
+19 rows in set (0.02 sec)
+
+mysql> select id, j, json_type(j, '$.k1') from test_json order by id;
++------+---------------------------------------------------------------+-------------------------+
+| id   | j                                                             | json_type(`j`, '$.k1') |
++------+---------------------------------------------------------------+-------------------------+
+|    1 |                                                          NULL | NULL                    |
+|    2 |                                                          null | NULL                    |
+|    3 |                                                          true | NULL                    |
+|    4 |                                                         false | NULL                    |
+|    5 |                                                           100 | NULL                    |
+|    6 |                                                         10000 | NULL                    |
+|    7 |                                                    1000000000 | NULL                    |
+|    8 |                                           1152921504606846976 | NULL                    |
+|    9 |                                                          6.18 | NULL                    |
+|   10 |                                                        "abcd" | NULL                    |
+|   11 |                                                            {} | NULL                    |
+|   12 |                                         {"k1":"v31","k2":300} | string                  |
+|   13 |                                                            [] | NULL                    |
+|   14 |                                                     [123,456] | NULL                    |
+|   15 |                                                 ["abc","def"] | NULL                    |
+|   16 |                              [null,true,false,100,6.18,"abc"] | NULL                    |
+|   17 |                            [{"k1":"v41","k2":400},1,"a",3.14] | NULL                    |
+|   18 | {"k1":"v31","k2":300,"a1":[{"k1":"v41","k2":400},1,"a",3.14]} | string                  |
+|   26 |                                          {"k1":"v1","k2":200} | string                  |
++------+---------------------------------------------------------------+-------------------------+
+19 rows in set (0.03 sec)
+
+```
+
+### FAQ {#faq}
+
+1. JSON의 null과 SQL의 NULL(즉, IS NULL)에는 차이가 있나요?
+
+네, 차이가 있습니다. JSON에서 null(예: {"key1": null})은 key1이라는 키가 존재하며 그 값이 명시적으로 null임을 의미합니다. 이는 JSON 바이너리로 인코딩되는 특수 타입입니다.
+
+반면 SQL NULL(IS NULL을 사용하는 경우)은 JSON 객체에 해당 키가 아예 없음을 나타낼 수 있습니다.
+
+예를 들어:
+
+``` sql
+mysql> SELECT JSON_EXTRACT_STRING('{"key1" : null}', "$.key1") IS NULL;
++----------------------------------------------------------+
+| JSON_EXTRACT_STRING('{"key1" : null}', "$.key1") IS NULL |
++----------------------------------------------------------+
+|                                                        0 |
++----------------------------------------------------------+
+1 row in set (0.00 sec)
+
+mysql> SELECT JSON_EXTRACT_STRING('{"key1" : null}', "$.key_not_exist") IS NULL;
++-------------------------------------------------------------------+
+| JSON_EXTRACT_STRING('{"key1" : null}', "$.key_not_exist") IS NULL |
++-------------------------------------------------------------------+
+|                                                                 1 |
++-------------------------------------------------------------------+
+1 row in set (0.01 sec)
+```
+
+2. `GET_JSON_XXX` 함수와 `JSON_EXTRACT_XXX` 함수는 어떻게 다르며, 어떤 것을 선택해야 하나요?
+
+`GET_JSON_XXX` 함수는 문자열 타입에 사용하도록 설계되어 원시 JSON 문자열에서 값을 직접 추출합니다. `JSON_EXTRACT_XXX` 함수는 JSON 데이터 타입 전용으로 구현되어 해당 타입에 최적화되어 있습니다.
+
+
+### 키워드 {#keywords}
+JSONB, JSON, json_parse, json_parse_error_to_null, json_parse_error_to_value, json_extract, json_extract_isnull, json_extract_bool, json_extract_int, json_extract_bigint, json_extract_double, json_extract_string, json_exists_path, json_type
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/MAP.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/MAP.md
new file mode 100644
index 00000000000..9ec71a7737c
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/MAP.md
@@ -0,0 +1,222 @@
+---
+{
+    "title": "MAP | 반정형",
+    "language": "ko",
+    "description": "```SQL SELECT MAP('Alice', 21, 'Bob', 23);",
+    "sidebar_label": "MAP"
+}
+---
+
+# MAP {#map}
+
+## 타입 설명 {#type-description}
+
+- `MAP<key_type, value_type>` 타입은 키와 값의 쌍으로 이루어진 복합 타입을 나타내며, 각 키는 하나의 값에 고유하게 대응합니다.
+  - `key_type`은 키의 타입을 나타내며, `BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL, DATE, DATETIME, TIMESTAMPTZ, CHAR, VARCHAR, STRING, IPV4, IPV6` 등의 타입을 지원합니다. 키는 NULL을 허용하며 NOT NULL로 지정할 수 없습니다.
+  - `value_type`은 값의 타입을 나타내며, `BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL, DATE, DATETIME, TIMESTAMPTZ, CHAR, VARCHAR, STRING, IPV4, IPV6, ARRAY, MAP, STRUCT`를 지원합니다. 값은 NULL을 허용하며 NOT NULL로 지정할 수 없습니다.
+
+## 타입 제약 사항 {#type-constraints}
+
+- `MAP<key_type, value_type>` 타입은 최대 9단계까지 중첩할 수 있습니다.
+- `MAP<key_type, value_type>`에서 키는 NULL일 수 있으며, 동일한 키도 허용됩니다(NULL과 NULL은 같은 키로 간주됩니다).
+- `MAP<key_type, value_type>` 타입 간의 변환 가능 여부는 `key_type`과 `value_type`의 변환 가능 여부에 따라 결정됩니다. `MAP<key_type, value_type>`는 다른 타입으로 변환할 수 없습니다.
+  - 예를 들어, `MAP<INT, INT>`는 `MAP<BIGINT, BIGINT>`로 변환할 수 있습니다. `INT`와 `BIGINT` 간에 변환이 가능하기 때문입니다.
+  - 문자열 타입은 `MAP<key_type, value_type>`로 변환할 수 있습니다(파싱을 통해 변환하며, 파싱에 실패하면 NULL을 반환합니다).
+- `AGGREGATE` 테이블 모델에서 `MAP<key_type, value_type>`는 `REPLACE`와 `REPLACE_IF_NOT_NULL`만 지원합니다. **어떤 테이블 모델에서도 KEY 컬럼, 파티션 컬럼 또는 버킷 컬럼으로 사용할 수 없습니다**.
+- `MAP<key_type, value_type>` 타입의 컬럼은 `IN`과 `NOT IN`을 포함한 비교 및 산술 연산을 지원하지 않으며, **`ORDER BY` 및 `GROUP BY` 연산을 지원하지 않고, `JOIN KEY`로 사용하거나 `DELETE` 문에서 사용할 수 없습니다**.
+- `MAP<key_type, value_type>` 타입의 컬럼에는 어떤 인덱스도 생성할 수 없습니다.
+
+## 타입 생성 {#type-construction}
+
+- `MAP()` 함수는 `MAP` 타입의 값을 반환할 수 있습니다.
+
+  ```SQL
+  SELECT MAP('Alice', 21, 'Bob', 23);
+
+  +-----------------------------+
+  | map('Alice', 21, 'Bob', 23) |
+  +-----------------------------+
+  | {"Alice":21, "Bob":23}      |
+  +-----------------------------+
+  ```
+
+- `{}`를 사용하여 `MAP` 타입의 값을 생성할 수 있습니다.
+
+  ```SQL
+  SELECT {'Alice': 20};
+
+  +---------------+
+  | {'Alice': 20} |
+  +---------------+
+  | {"Alice":20}  |
+  +---------------+
+  ```
+
+## 타입 변경 {#modifying-type}
+
+- 변경은 `key_type` 또는 `value_type`이 해당 `MAP<key_type, value_type>` 타입에서 `VARCHAR`인 경우에만 허용됩니다.
+  - `VARCHAR`의 매개변수 값은 늘리는 것만 허용되며 줄일 수는 없습니다.
+
+    ```SQL
+    CREATE TABLE `map_table` (
+      `k` INT NOT NULL,
+      `map_varchar_int` MAP<VARCHAR(10), INT>,
+      `map_int_varchar` MAP<INT, VARCHAR(10)>,
+      `map_varchar_varchar` MAP<VARCHAR(10), VARCHAR(10)>
+    ) ENGINE=OLAP
+    DUPLICATE KEY(`k`)
+    DISTRIBUTED BY HASH(`k`) BUCKETS 1
+    PROPERTIES (
+        "replication_num" = "1"
+    );
+
+    ALTER TABLE map_table MODIFY COLUMN map_varchar_int MAP<VARCHAR(20), INT>;
+
+    ALTER TABLE map_table MODIFY COLUMN map_int_varchar MAP<INT, VARCHAR(20)>;
+
+    ALTER TABLE map_table MODIFY COLUMN map_varchar_varchar MAP<VARCHAR(20), VARCHAR(20)>;
+    ```
+
+- `MAP<key_type, value_type>` 타입 컬럼의 기본값은 NULL로만 지정할 수 있으며, 한 번 지정하면 변경할 수 없습니다.
+
+## 요소 접근 {#element-access}
+
+- `[key]`를 사용하여 `MAP`에서 해당 키에 대응하는 값에 접근합니다.
+
+  ```SQL
+  SELECT {'Alice': 20}['Alice'];
+
+  +------------------------+
+  | {'Alice': 20}['Alice'] |
+  +------------------------+
+  |                     20 |
+  +------------------------+
+  ```
+
+- `ELEMENT_AT(MAP, Key)`를 사용하여 `MAP`에서 해당 키에 대응하는 값에 접근합니다.
+
+  ```SQL
+  SELECT ELEMENT_AT({'Alice': 20}, 'Alice');
+
+  +------------------------------------+
+  | ELEMENT_AT({'Alice': 20}, 'Alice') |
+  +------------------------------------+
+  |                                 20 |
+  +------------------------------------+
+  ```
+
+## 예제 {#examples}
+
+- 중첩 MAP
+
+  ```SQL
+  -- Create table
+  CREATE TABLE IF NOT EXISTS map_table (
+      id INT,
+      map_nested MAP<STRING, MAP<STRING, INT>>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(id)
+  DISTRIBUTED BY HASH(id) BUCKETS 1
+  PROPERTIES (
+      "replication_allocation" = "tag.location.default: 1"
+  );
+
+  -- Insert
+  INSERT INTO map_table VALUES (1, MAP('key1', MAP('key2', 1, 'key3', 2)));
+  INSERT INTO map_table VALUES (2, MAP('key1', MAP('key2', 3, 'key3', 4)));
+
+  -- Query
+  SELECT map_nested['key1']['key2'] FROM map_table ORDER BY id;
+  +----------------------------+
+  | map_nested['key1']['key2'] |
+  +----------------------------+
+  |                          1 |
+  |                          3 |
+  +----------------------------+
+  ```
+
+- 중첩 복합 타입
+
+  ```SQL
+  -- Create table
+  CREATE TABLE IF NOT EXISTS map_table (
+      id INT,
+      map_array MAP<STRING, ARRAY<INT>>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(id)
+  DISTRIBUTED BY HASH(id) BUCKETS 1
+  PROPERTIES (
+      "replication_allocation" = "tag.location.default: 1"
+  );
+
+  -- Insert
+  INSERT INTO map_table VALUES (1, MAP('key1', [1, 2, 3])), (2, MAP('key1', [4, 5, 6]));
+
+  -- Query
+  SELECT map_array['key1'][1] FROM map_table ORDER BY id;
+  +----------------------+
+  | map_array['key1'][1] |
+  +----------------------+
+  |                    1 |
+  |                    4 |
+  +----------------------+
+
+  -- Create table
+  CREATE TABLE IF NOT EXISTS map_table (
+      id INT,
+      map_struct MAP<STRING, STRUCT<id: INT, name: STRING>>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(id)
+  DISTRIBUTED BY HASH(id) BUCKETS 1
+  PROPERTIES (
+      "replication_allocation" = "tag.location.default: 1"
+  );
+
+  -- Insert
+  INSERT INTO map_table VALUES (1, MAP('key1', STRUCT(1, 'John'), 'key2', STRUCT(3, 'Jane')));
+
+  -- Query
+  SELECT STRUCT_ELEMENT(map_struct['key1'], 1), STRUCT_ELEMENT(map_struct['key1'], 'name') FROM map_table ORDER BY id;
+  +---------------------------------------+--------------------------------------------+
+  | STRUCT_ELEMENT(map_struct['key1'], 1) | STRUCT_ELEMENT(map_struct['key1'], 'name') |
+  +---------------------------------------+--------------------------------------------+
+  |                                     1 | John                                       |
+  +---------------------------------------+--------------------------------------------+
+  ```
+
+- 타입 변경
+
+  ```SQL
+  -- Create table
+  CREATE TABLE `map_table` (
+    `k` INT NOT NULL,
+    `map_varchar_int` MAP<VARCHAR(10), INT>,
+    `map_int_varchar` MAP<INT, VARCHAR(10)>,
+    `map_varchar_varchar` MAP<VARCHAR(10), VARCHAR(10)>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(`k`)
+  DISTRIBUTED BY HASH(`k`) BUCKETS 1
+  PROPERTIES (
+      "replication_num" = "1"
+  );
+
+  -- Modify KEY
+  ALTER TABLE map_table MODIFY COLUMN map_varchar_int MAP<VARCHAR(20), INT>;
+
+  -- Modify VALUE
+  ALTER TABLE map_table MODIFY COLUMN map_int_varchar MAP<INT, VARCHAR(20)>;
+
+  -- Modify KEY and VALUE
+  ALTER TABLE map_table MODIFY COLUMN map_varchar_varchar MAP<VARCHAR(20), VARCHAR(20)>;
+
+  -- Check column types
+  DESC map_table;
+  +---------------------+------------------------------+------+-------+---------+-------+
+  | Field               | Type                         | Null | Key   | Default | Extra |
+  +---------------------+------------------------------+------+-------+---------+-------+
+  | k                   | int                          | No   | true  | NULL    |       |
+  | map_varchar_int     | map<varchar(20),int>         | Yes  | false | NULL    | NONE  |
+  | map_int_varchar     | map<int,varchar(20)>         | Yes  | false | NULL    | NONE  |
+  | map_varchar_varchar | map<varchar(20),varchar(20)> | Yes  | false | NULL    | NONE  |
+  +---------------------+------------------------------+------+-------+---------+-------+
+  ```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/STRUCT.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/STRUCT.md
new file mode 100644
index 00000000000..42d0b9f198e
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/STRUCT.md
@@ -0,0 +1,248 @@
+---
+{
+    "title": "STRUCT | 반정형",
+    "language": "ko",
+    "description": "STRUCT 타입은 여러 필드를 하나의 구조로 결합하는 데 사용되며, 각 필드는 고유한 이름과 타입을 가질 수 있습니다.",
+    "sidebar_label": "STRUCT"
+}
+---
+
+# STRUCT {#struct}
+
+## 타입 설명 {#type-description}
+
+STRUCT 타입은 여러 필드를 하나의 구조로 결합하는 데 사용됩니다. 각 필드는 고유한 이름과 타입을 가질 수 있어, 중첩되거나 복잡한 비즈니스 데이터 구조를 표현하는 데 적합합니다.
+
+- `STRUCT<field_name:field_type [COMMENT 'comment_string'], ... >`
+
+  - `field_name`은 필드 이름을 나타내며, **비어 있거나 중복될 수 없고 대소문자를 구분하지 않습니다**.
+
+  - `field_type`은 필드 타입을 나타내며, NULL을 허용하고 NOT NULL로 지정할 수 없습니다. 지원되는 타입은 다음과 같습니다: `BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL, DATE, DATETIME, TIMESTAMPTZ, CHAR, VARCHAR, STRING, IPV4, IPV6, ARRAY, MAP, STRUCT`.
+
+  - `[COMMENT 'comment-string']`은 선택 사항인 주석을 나타냅니다.
+
+## 타입 제약 사항 {#type-constraints}
+
+- `STRUCT` 타입이 지원하는 최대 중첩 깊이는 9입니다.
+
+- `STRUCT` 타입 간 변환 가능 여부는 내부 타입을 변환할 수 있는지에 따라 결정됩니다(이름은 변환에 영향을 주지 않습니다). `STRUCT` 타입은 다른 타입으로 변환할 수 없습니다.
+
+  - 문자열 타입은 `STRUCT` 타입으로 변환할 수 있습니다(파싱을 통해 변환하며, 파싱에 실패하면 NULL을 반환합니다).
+
+- `AGGREGATE` 테이블 모델에서 `STRUCT` 타입은 `REPLACE`와 `REPLACE_IF_NOT_NULL`만 지원합니다. **어떤 테이블 모델에서도 KEY 열이나 파티션 열, 버킷 열로 사용할 수 없습니다.**
+
+- `STRUCT` 타입의 열은 `IN`과 `NOT IN`을 포함한 비교 연산이나 산술 연산을 지원하지 않으며, **`ORDER BY`와 `GROUP BY` 연산을 지원하지 않고, `JOIN KEY`로 사용할 수 없으며, `DELETE` 문에서도 사용할 수 없습니다.**
+
+- `STRUCT` 타입의 열에는 어떤 인덱스도 생성할 수 없습니다.
+
+## 타입 값 생성 {#type-construction}
+
+- `STRUCT()`를 사용하여 `STRUCT` 타입의 값을 생성합니다. 내부 필드 이름은 col1부터 시작합니다.
+
+  ```SQL
+  SELECT STRUCT(1, 'a', "abc");
+
+  +--------------------------------------+
+  | STRUCT(1, 'a', "abc")                |
+  +--------------------------------------+
+  | {"col1":1, "col2":"a", "col3":"abc"} |
+  +--------------------------------------+
+  ```
+
+- `NAMED_STRUCT()`를 사용하여 필드 이름을 지정한 `STRUCT` 타입의 값을 생성합니다.
+
+  ```SQL
+  SELECT NAMED_STRUCT("name", "Jack", "id", 1728923);
+
+  +---------------------------------------------+
+  | NAMED_STRUCT("name", "Jack", "id", 1728923) |
+  +---------------------------------------------+
+  | {"name":"Jack", "id":1728923}               |
+  +---------------------------------------------+
+  ```
+
+## 타입 변경 {#modifying-type}
+
+- `STRUCT`의 하위 열 타입이 `VARCHAR`인 경우에만 변경할 수 있습니다.
+
+   - `VARCHAR`의 매개변수는 작은 값에서 큰 값으로만 변경할 수 있으며, 반대로는 변경할 수 없습니다.
+
+  ```SQL
+  CREATE TABLE struct_table (
+      `k` INT NOT NULL,
+      `struct_varchar` STRUCT<name: VARCHAR(10), age: INT>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(`k`)
+  DISTRIBUTED BY HASH(`k`) BUCKETS 1
+  PROPERTIES (
+      "replication_num" = "1"
+  );
+
+  ALTER TABLE struct_table MODIFY COLUMN struct_varchar STRUCT<name: VARCHAR(20), age: INT>;
+  ``` 
+
+- `STRUCT` 타입 내부의 하위 열은 삭제할 수 없지만, 끝에 새 하위 열을 추가할 수 있습니다.
+
+```SQL
+  CREATE TABLE struct_table (
+      `k` INT NOT NULL,
+      `struct_varchar` STRUCT<name: VARCHAR(10), age: INT>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(`k`)
+  DISTRIBUTED BY HASH(`k`) BUCKETS 1
+  PROPERTIES (
+      "replication_num" = "1"
+  );
+
+  -- Add a subcolumn at the end
+  ALTER TABLE struct_table MODIFY COLUMN struct_varchar STRUCT<name: VARCHAR(10), age: INT, id: INT>;
+```
+
+## 요소 접근 {#element-access}
+
+`STRUCT` 내부의 특정 하위 열에는 다음과 같은 동등한 방식으로 접근할 수 있습니다.
+
+- `ELEMENT_AT(struct, k/field_name)` 함수.
+
+- 아래첨자 연산자 `struct[k]` / `struct['field_name']`.
+
+- 점 연산자 `struct_col.field_name`(`STRUCT` 열에만 사용 가능).
+
+여기서 `k`는 위치(1부터 시작하는 상수)이고, `field_name`은 하위 열 이름(문자열 상수)입니다. 필드 이름은 **대소문자를 구분하지 않고** 일치 여부를 판단합니다. 존재하지 않는 필드 이름이나 범위를 벗어난 위치에 접근하면 오류가 발생합니다.
+
+:::caution
+다른 데이터베이스나 쿼리 엔진에서 이러한 함수를 제공하지 않으므로, `STRUCT_ELEMENT`는 버전 4.1.3부터 제거되었습니다. 대신 `ELEMENT_AT` 또는 아래첨자 / 점 연산자를 사용하세요.
+:::
+
+- `ELEMENT_AT` 또는 아래첨자 연산자를 사용하여 위치나 필드 이름으로 접근합니다.
+
+  ```SQL
+  SELECT ELEMENT_AT(NAMED_STRUCT("name", "Jack", "id", 1728923), 1);
+
+  +------------------------------------------------------------+
+  | ELEMENT_AT(NAMED_STRUCT('name', 'Jack', 'id', 1728923), 1) |
+  +------------------------------------------------------------+
+  | Jack                                                       |
+  +------------------------------------------------------------+
+
+  SELECT NAMED_STRUCT("name", "Jack", "id", 1728923)['id'];
+
+  +--------------------------------------------------+
+  | NAMED_STRUCT('name', 'Jack', 'id', 1728923)['id'] |
+  +--------------------------------------------------+
+  |                                          1728923 |
+  +--------------------------------------------------+
+  ```
+
+- `STRUCT` 열에서는 점 연산자를 사용하여 이름으로 하위 열에 접근할 수 있으며, `s.a.b`와 같은 중첩 접근도 가능합니다.
+
+  ```SQL
+  -- Table with a STRUCT column: s STRUCT<a: INT, b: DOUBLE>
+  SELECT s.a, s.b FROM struct_table;
+
+  -- Nested STRUCT column: s STRUCT<s: STRUCT<s: STRUCT<s: INT>>>
+  SELECT s.s.s.s FROM nested_struct_table;
+  ```
+
+## 예제 {#examples}
+
+- 중첩된 복합 타입
+
+  ```SQL
+  -- Create table
+  CREATE TABLE IF NOT EXISTS struct_table (
+      id INT,
+      struct_complex STRUCT<
+          basic_info: STRUCT<name: STRING, age: INT>,
+          contact: STRUCT<email: STRING, phone: STRING>,
+          preferences: STRUCT<tags: ARRAY<STRING>, settings: MAP<STRING, INT>>,
+          metadata: STRUCT<
+              created_at: DATETIME,
+              updated_at: DATETIME,
+              stats: STRUCT<views: INT, clicks: INT>
+          >
+      >
+  ) ENGINE=OLAP
+  DUPLICATE KEY(id)
+  DISTRIBUTED BY HASH(id) BUCKETS 1
+  PROPERTIES (
+      "replication_allocation" = "tag.location.default: 1"
+  );
+
+  -- Insert
+  INSERT INTO struct_table VALUES (1, STRUCT(
+    STRUCT('John', 25),
+    STRUCT('john@example.com', '1234567890'),
+    STRUCT(['tag1', 'tag2'], MAP('setting1', 1, 'setting2', 2)),
+    STRUCT('2021-01-01 00:00:00', '2021-01-02 00:00:00', STRUCT(100, 50))
+  ));
+
+  -- Query (use the dot operator for nested struct field access)
+  SELECT struct_complex.basic_info.name FROM struct_table ORDER BY id;
+
+  +--------------------------------+
+  | struct_complex.basic_info.name |
+  +--------------------------------+
+  | John                           |
+  +--------------------------------+
+
+  SELECT struct_complex.metadata.stats.views FROM struct_table ORDER BY id;
+
+  +-------------------------------------+
+  | struct_complex.metadata.stats.views |
+  +-------------------------------------+
+  |                                 100 |
+  +-------------------------------------+
+  ```
+
+- 타입 변경
+
+```SQL
+-- Create table
+CREATE TABLE struct_table (
+      `k` INT NOT NULL,
+      `struct_varchar` STRUCT<name: VARCHAR(10), age: INT>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(`k`)
+  DISTRIBUTED BY HASH(`k`) BUCKETS 1
+  PROPERTIES (
+      "replication_num" = "1"
+  );
+
+  -- Modify the type of the 'name' subcolumn
+  ALTER TABLE struct_table MODIFY COLUMN struct_varchar STRUCT<name: VARCHAR(20), age: INT>;
+
+  -- Check column types
+  DESC struct_table;
+
+  +----------------+----------------------------------+------+-------+---------+-------+
+  | Field          | Type                             | Null | Key   | Default | Extra |
+  +----------------+----------------------------------+------+-------+---------+-------+
+  | k              | int                              | No   | true  | NULL    |       |
+  | struct_varchar | struct<name:varchar(20),age:int> | Yes  | false | NULL    | NONE  |
+  +----------------+----------------------------------+------+-------+---------+-------+
+
+  -- Create table
+  CREATE TABLE struct_table (
+      `k` INT NOT NULL,
+      `struct_varchar` STRUCT<name: VARCHAR(10), age: INT>
+  ) ENGINE=OLAP
+  DUPLICATE KEY(`k`)
+  DISTRIBUTED BY HASH(`k`) BUCKETS 1
+  PROPERTIES (
+      "replication_num" = "1"
+  );
+
+  -- Add a subcolumn at the end
+  ALTER TABLE struct_table MODIFY COLUMN struct_varchar STRUCT<name: VARCHAR(10), age: INT, id: INT>;
+
+  -- Check column types
+  DESC struct_table;
+
+  +----------------+-----------------------------------------+------+-------+---------+-------+
+  | Field          | Type                                    | Null | Key   | Default | Extra |
+  +----------------+-----------------------------------------+------+-------+---------+-------+
+  | k              | int                                     | No   | true  | NULL    |       |
+  | struct_varchar | struct<name:varchar(10),age:int,id:int> | Yes  | false | NULL    | NONE  |
+  +----------------+-----------------------------------------+------+-------+---------+-------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/VARIANT.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/VARIANT.md
new file mode 100644
index 00000000000..f2e597184c5
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/VARIANT.md
@@ -0,0 +1,624 @@
+---
+{
+    "title": "VARIANT",
+    "language": "ko",
+    "description": "VARIANT 타입은 반정형 JSON 데이터를 저장합니다. 다양한 기본 타입(정수, 문자열, 불리언 등), 일차원 배열, 중첩 객체를 포함할 수 있습니다. 데이터를 쓸 때 Doris는 JSON 경로를 기반으로 하위 경로의 구조와 타입을 추론하고, 자주 사용되는 경로에 Subcolumnization을 수행하여 독립적인 컬럼형 하위 컬럼으로 노출합니다. 이를 통해 유연성과 성능을 모두 확보합니다."
+}
+---
+
+## VARIANT {#variant}
+
+## 개요 {#overview}
+
+VARIANT 타입은 반정형 JSON 데이터를 저장합니다. 다양한 기본 타입(정수, 문자열, 불리언 등), 일차원 배열, 중첩 객체를 포함할 수 있습니다. 데이터를 쓸 때 Doris는 JSON 경로를 기반으로 하위 경로의 구조와 타입을 추론하고, 자주 사용되는 경로에 Subcolumnization을 수행하여 독립적인 컬럼형 하위 컬럼으로 노출합니다. 이를 통해 유연성과 성능을 모두 확보합니다.
+
+:::tip VARIANT를 사용하는 이유
+`VARIANT`는 시간이 지남에 따라 문서 구조가 바뀌지만 쿼리는 소수의 자주 사용되는 경로에 집중되는 경우에 적합합니다.
+
+- 자주 사용되는 경로는 Subcolumnization 대상이 되므로 컬럼형 처리 성능, 파일 프루닝, 벡터화 실행의 이점을 얻습니다.
+- 주요 경로에는 경로 수준 인덱스와 전문 검색을 사용할 수 있으며, Doris 희소 인덱스 프루닝의 이점도 얻을 수 있습니다.
+- 와이드 컬럼 최적화를 통해 10k 규모의 하위 컬럼에서도 자동 Subcolumnization을 실용적으로 사용할 수 있습니다. Subcolumnization 대상 경로가 10,000개에 가까워지면 하드웨어 요구 사항이 빠르게 증가하므로, 일반적으로 DOC 모드로 시작하는 편이 더 안전합니다.
+
+기본 동작, 희소 컬럼, DOC 모드, Schema Template 중 무엇을 선택할지 결정해야 한다면 [Variant 워크로드 가이드](./variant-workload-guide)부터 확인하세요. 이 페이지는 구문, 타입 규칙, 인덱스, 제한 사항, 설정에 대한 참조 문서입니다.
+:::
+
+## VARIANT 사용 {#using-variant}
+
+### 테이블 생성 구문 {#create-table-syntax}
+
+테이블을 생성할 때 VARIANT 컬럼을 선언합니다.
+
+```sql
+CREATE TABLE IF NOT EXISTS ${table_name} (
+    k BIGINT,
+    v VARIANT
+)
+PROPERTIES("replication_num" = "1");
+```
+
+최상위 VARIANT 컬럼 이름에는 백틱으로 감싸더라도 점(`.`)을 포함할 수 없습니다. 예를 들어 `` `v.x` VARIANT ``는 유효하지 않습니다. 이 제한은 `CREATE TABLE`과 `ALTER TABLE`에 적용되며, VARIANT 값 내부의 JSON 필드 이름은 제한하지 않습니다.
+
+`ADD COLUMN`(일괄 추가 포함), `MODIFY COLUMN`, `RENAME COLUMN`에서도 점이 없는 최상위 VARIANT 컬럼 이름을 사용해야 합니다. 예를 들어 다음 구문은 거부됩니다.
+
+```sql
+ALTER TABLE ${table_name} ADD COLUMN `v.x` VARIANT;
+-- ERROR: Cannot use `VARIANT` type column named with a `.` character: v.x
+```
+
+Schema Template으로 특정 경로에 제약을 지정합니다(“확장 타입” 참조).
+
+```sql
+CREATE TABLE IF NOT EXISTS ${table_name} (
+    k BIGINT,
+    v VARIANT <
+        'id' : INT,            -- restrict path id to INT
+        'message*' : STRING,   -- restrict message* prefix to STRING
+        'tags*' : ARRAY<TEXT>  -- restrict tags* prefix to ARRAY<TEXT>
+    >
+)
+PROPERTIES("replication_num" = "1");
+```
+
+### 쿼리 구문 {#query-syntax}
+
+```sql
+-- Access nested fields (returns VARIANT; explicit or implicit CAST is required for aggregation/comparison)
+SELECT v['properties']['title'] FROM ${table_name};
+
+-- CAST to a concrete type before aggregation
+SELECT CAST(v['properties']['title'] AS STRING) AS title
+FROM ${table_name}
+GROUP BY title;
+
+-- Query arrays
+SELECT *
+FROM ${table_name}
+WHERE ARRAY_CONTAINS(CAST(v['tags'] AS ARRAY<TEXT>), 'Doris');
+```
+
+## 기본 타입 {#primitive-types}
+
+VARIANT는 하위 컬럼의 타입을 자동으로 추론합니다. 지원되는 타입은 다음과 같습니다.
+
+<table>
+<tr><td>지원되는 타입<br/></td></tr>
+<tr><td>TinyInt<br/></td></tr>
+<tr><td>NULL (JSON null과 동일)<br/></td></tr>
+<tr><td>BigInt (64비트)<br/>Double<br/></td></tr>
+<tr><td>String (Text)<br/></td></tr>
+<tr><td>Jsonb<br/></td></tr>
+<tr><td>Variant (중첩 객체)<br/></td></tr>
+<tr><td>Array&lt;T&gt; (일차원만 지원)<br/></td></tr>
+</table>
+
+간단한 INSERT 예제:
+
+```sql
+INSERT INTO vartab VALUES
+  (1, 'null'),
+  (2, NULL),
+  (3, 'true'),
+  (4, '-17'),
+  (5, '123.12'),
+  (6, '1.912'),
+  (7, '"A quote"'),
+  (8, '[-1, 12, false]'),
+  (9, '{ "x": "abc", "y": false, "z": 10 }'),
+  (10, '"2021-01-01"');
+```
+
+팁: 날짜/시간처럼 JSON 표준에 없는 타입은 Schema Template을 지정하지 않으면 문자열로 저장됩니다. 연산 효율을 높이려면 정적 컬럼으로 추출하거나 Schema Template으로 타입을 선언하는 방법을 고려하세요.
+
+## 확장 타입 (Schema Template) {#extended-types-schema-template}
+
+VARIANT는 기본 타입 외에도 Schema Template을 통해 다음 확장 타입을 지원합니다.
+
+- 숫자 (확장)
+  - Decimal: Decimal32 / Decimal64 / Decimal128 / Decimal256
+  - LargeInt
+- Datetime
+- Timestamptz
+- Date
+- IPV4 / IPV6
+- Boolean
+- ARRAY&lt;T&gt; (T는 위 타입 중 하나이며, 일차원만 지원)
+
+참고: 사전 정의 스키마는 테이블 생성 시에만 지정할 수 있습니다. 현재 ALTER는 지원되지 않습니다(향후 버전에서 새로운 하위 컬럼 정의 추가를 지원할 수 있지만, 기존 하위 컬럼의 타입 변경은 지원되지 않습니다).
+
+예제:
+
+```sql
+CREATE TABLE test_var_schema (
+    id BIGINT NOT NULL,
+    v1 VARIANT<
+        'large_int_val': LARGEINT,
+        'string_val': STRING,
+        'decimal_val': DECIMAL(38, 9),
+        'datetime_val': DATETIME,
+        'tz_val': TIMESTAMPTZ,
+        'ip_val': IPV4
+    > NULL
+)
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO test_var_schema VALUES (1, '{
+    "large_int_val" : "123222222222222222222222",
+    "string_val" : "Hello World",
+    "decimal_val" : 1.11111111,
+    "datetime_val" : "2025-05-16 11:11:11",
+    "tz_val" : "2025-05-16 11:11:11+08:00",
+    "ip_val" : "127.0.0.1"
+}');
+
+SELECT variant_type(v1) FROM test_var_schema;
+
++---------------------------------------------------------------------------------------------------------------------------------------------------+
+| variant_type(v1)                                                                                                                                  |
++---------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"datetime_val":"datetimev2","decimal_val":"decimal128i","ip_val":"ipv4","large_int_val":"largeint","string_val":"string","tz_val":"timestamptz"} |
++---------------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+`{"date": 2020-01-01}`과 `{"ip": 127.0.0.1}`은 유효하지 않은 JSON 텍스트입니다. 올바른 형식은 `{"date": "2020-01-01"}`과 `{"ip": "127.0.0.1"}`입니다.
+
+Schema Template을 지정한 후 JSON 값이 선언된 타입과 충돌하고 변환할 수 없으면 해당 값은 NULL로 저장됩니다. 예를 들면 다음과 같습니다.
+
+```sql
+INSERT INTO test_var_schema VALUES (1, '{
+  "decimal_val" : "1.11111111",
+  "ip_val" : "127.xxxxxx.xxxx",
+  "large_int_val" : "aaabbccc"
+}');
+
+-- Only decimal_val remains
+SELECT * FROM test_var_schema;
+
++------+-----------------------------+
+| id   | v1                          |
++------+-----------------------------+
+|    1 | {"decimal_val":1.111111110} |
++------+-----------------------------+
+```
+
+스키마는 영구 저장 시의 타입만 결정합니다. 쿼리 실행 중 실제로 사용되는 타입은 런타임의 실제 데이터에 따라 달라집니다.
+
+```sql
+-- At runtime v['a'] may still be STRING
+SELECT variant_type(CAST('{"a" : "12345"}' AS VARIANT<'a' : INT>)['a']);
+```
+
+와일드카드 매칭과 순서:
+
+```sql
+CREATE TABLE test_var_schema (
+    id BIGINT NOT NULL,
+    v1 VARIANT<
+        'enumString*' : STRING,
+        'enum*' : ARRAY<TEXT>,
+        'ip*' : IPV6
+    > NULL
+)
+PROPERTIES ("replication_num" = "1");
+
+-- If enumString1 matches both patterns, the first matching pattern in definition order (STRING) is used
+```
+
+컬럼 이름에 `*`가 포함되어 있고 이를 접두사 와일드카드가 아닌 이름 그대로 매칭하려면 다음과 같이 사용합니다.
+
+```sql
+v1 VARIANT<
+    MATCH_NAME 'enumString*' : STRING
+> NULL
+```
+
+매칭된 하위 경로는 기본적으로 Subcolumnization 대상이 되어 컬럼으로 노출됩니다. 매칭되는 경로가 너무 많아 컬럼이 과도하게 생성된다면 `variant_enable_typed_paths_to_sparse`를 활성화하는 방법을 고려하세요(“설정” 참조).
+
+## 타입 충돌 및 승격 규칙 {#type-conflicts-and-promotion-rules}
+
+동일한 경로에 호환되지 않는 타입이 나타나면(예: 동일한 필드가 정수와 문자열로 모두 나타나는 경우), 정보 손실을 방지하기 위해 타입이 JSONB로 승격됩니다.
+
+```sql
+{"a" : 12345678}
+{"a" : "HelloWorld"}
+-- a will be promoted to JSONB
+```
+
+승격 규칙:
+
+| 원본 타입    | 현재 타입  | 최종 타입   |
+| -------------- | ------------- | ------------ |
+| `TinyInt`      | `BigInt`      | `BigInt`     |
+| `TinyInt`      | `Double`      | `Double`     |
+| `TinyInt`      | `String`      | `JSONB`      |
+| `TinyInt`      | `Array`       | `JSONB`      |
+| `BigInt`       | `Double`      | `JSONB`      |
+| `BigInt`       | `String`      | `JSONB`      |
+| `BigInt`       | `Array`       | `JSONB`      |
+| `Double`       | `String`      | `JSONB`      |
+| `Double`       | `Array`       | `JSONB`      |
+| `Array<Double>`| `Array<String>`| `Array<Jsonb>` |
+
+안정적인 인덱싱과 저장을 위해 엄격한 타입 지정이 필요하다면 Schema Template으로 타입을 선언하세요.
+
+## Variant 인덱스 {#variant-indexes}
+
+### 인덱스 선택 {#choosing-indexes}
+
+VARIANT는 하위 경로에 BloomFilter와 Inverted Index를 지원합니다.
+- 카디널리티가 높은 동등/IN 필터: BloomFilter를 권장합니다(더 희소한 인덱스, 더 나은 쓰기 성능).
+- 토큰화/구문/범위 검색: Inverted Index를 사용하고 적절한 `parser`/`analyzer` 속성을 설정합니다.
+
+```sql
+...  
+PROPERTIES("replication_num" = "1", "bloom_filter_columns" = "v");
+
+-- Use BloomFilter for equality/IN filters
+SELECT * FROM tbl WHERE v['id'] = 12345678;
+SELECT * FROM tbl WHERE v['id'] IN (1, 2, 3);
+```
+
+VARIANT 컬럼에 역색인을 생성하면 모든 하위 경로가 동일한 인덱스 속성(예: parser)을 상속합니다.
+
+```sql
+CREATE TABLE IF NOT EXISTS tbl (
+    k BIGINT,
+    v VARIANT,
+    INDEX idx_v(v) USING INVERTED PROPERTIES("parser" = "english")
+);
+
+-- All subpaths inherit the english parser
+SELECT * FROM tbl WHERE v['id_1'] MATCH 'Doris';
+SELECT * FROM tbl WHERE v['id_2'] MATCH 'Apache';
+```
+
+### 하위 경로별 인덱스 {#index-by-subpath}
+
+3.1.x/4.0 이상에서는 특정 VARIANT 하위 경로에 인덱스 속성을 지정할 수 있으며, 동일한 경로에 토큰화 역색인과 비토큰화 역색인을 모두 설정할 수도 있습니다. 경로별 인덱스를 사용하려면 Schema Template으로 경로의 타입을 선언해야 합니다.
+
+```sql
+-- Common properties: field_pattern (target path), analyzer, parser, support_phrase, etc.
+CREATE TABLE IF NOT EXISTS tbl (
+    k BIGINT,
+    v VARIANT<'content' : STRING>,
+    INDEX idx_tokenized(v) USING INVERTED PROPERTIES("parser" = "english", "field_pattern" = "content"),
+    INDEX idx_v(v) USING INVERTED PROPERTIES("field_pattern" = "content")
+);
+
+-- v.content has both tokenized and non-tokenized inverted indexes
+SELECT * FROM tbl WHERE v['content'] MATCH 'Doris';
+SELECT * FROM tbl WHERE v['content'] = 'Doris';
+```
+
+와일드카드 경로 인덱싱:
+
+```sql
+CREATE TABLE IF NOT EXISTS tbl (
+    k BIGINT,
+    v VARIANT<'pattern_*' : STRING>,
+    INDEX idx_tokenized(v) USING INVERTED PROPERTIES("parser" = "english", "field_pattern" = "pattern_*"),
+    INDEX idx_v(v) USING INVERTED -- global non-tokenized inverted index
+);
+
+SELECT * FROM tbl WHERE v['pattern_1'] MATCH 'Doris';
+SELECT * FROM tbl WHERE v['pattern_1'] = 'Doris';
+```
+
+참고: 2.1.7+에서는 InvertedIndex V2 속성만 지원합니다(파일 수 감소, 쓰기 IOPS 감소, 스토리지와 컴퓨팅이 분리된 환경에 적합). 2.1.8+에서는 오프라인 Build Index가 제거되었습니다.
+
+Doris 4.1.5부터 아래 인덱스 속성 또는 BE 설정으로 norms를 비활성화할 수 있습니다.
+
+VARIANT 경로의 토큰화 인덱스는 기본적으로 BM25 norms를 기록하며, 해당 경로에 값이 없는 행을 포함하여 경로별로 행당 한 바이트를 사용합니다. 필터링에만 사용하는 경로는 `"norms" = "false"`로 norms를 비활성화하세요. `field_pattern`이 없으면 이 속성은 해당 인덱스가 포함하는 모든 하위 경로에 적용됩니다.
+
+```sql
+CREATE TABLE IF NOT EXISTS tbl (
+    k BIGINT,
+    v VARIANT<'body_*' : STRING>,
+    INDEX idx_body(v) USING INVERTED PROPERTIES("parser" = "english", "field_pattern" = "body_*", "norms" = "false")
+);
+```
+
+norms를 비활성화해도 `MATCH` 필터링에는 영향을 주지 않지만, `score()`가 norms가 없는 세그먼트를 읽으면 오류가 발생합니다. BE 설정 `inverted_index_skip_norms_for_variant`는 모든 VARIANT 경로의 norms를 비활성화합니다. 자세한 내용은 [레코드 길이와 norms 속성](../../../../table-design/index/inverted-index/scoring.md#record-length-and-the-norms-property)을 참조하세요.
+
+### 인덱스가 작동하지 않는 경우 {#when-indexes-dont-work}
+
+1. 타입 변경으로 인한 인덱스 손실: 하위 경로가 호환되지 않는 타입으로 변경되면(예: INT → JSONB) 인덱스가 손실됩니다. Schema Template으로 타입과 인덱스를 고정하여 해결하세요.
+2. 쿼리 타입 불일치:
+   ```sql
+   -- v['id'] is actually STRING; using INT equality causes index not to be used
+   SELECT * FROM tbl WHERE v['id'] = 123456;
+   ```
+3. 잘못된 인덱스 설정: 인덱스는 전체 VARIANT 컬럼이 아닌 하위 경로에 적용됩니다.
+   ```sql
+   -- VARIANT itself cannot be indexed as a whole
+   SELECT * FROM tbl WHERE v MATCH 'Doris';
+
+   -- If whole-JSON search is needed, store a duplicate STRING column and index it
+   CREATE TABLE IF NOT EXISTS tbl (
+       k BIGINT,
+       v VARIANT,
+       v_str STRING,
+       INDEX idx_v_str(v_str) USING INVERTED PROPERTIES("parser" = "english")
+   );
+   SELECT * FROM tbl WHERE v_str MATCH 'Doris';
+   ```
+
+## INSERT 및 데이터 적재 {#insert-and-load}
+
+### INSERT INTO VALUES {#insert-into-values}
+
+```sql
+CREATE TABLE IF NOT EXISTS variant_tbl (
+    k BIGINT,
+    v VARIANT
+) PROPERTIES("replication_num" = "1");
+
+INSERT INTO variant_tbl VALUES (1, '{"a" : 123}');
+
+select * from variant_tbl;
++------+-----------+
+| k    | v         |
++------+-----------+
+|    1 | {"a":123} |
++------+-----------+
+
+-- v['a'] is a VARIANT
+select v['a'] from variant_tbl;
++--------+
+| v['a'] |
++--------+
+| 123    |
++--------+
+
+-- Accessing a non-existent key returns NULL
+select v['a']['no_such_key'] from variant_tbl;;
++-----------------------+
+| v['a']['no_such_key'] |
++-----------------------+
+| NULL                  |
++-----------------------+
+
+```
+
+### 데이터 적재 (Stream Load) {#load-stream-load}
+
+```bash
+# Line-delimited JSON (one JSON record per line)
+curl --location-trusted -u root: -T gh_2022-11-07-3.json \
+  -H "read_json_by_line:true" -H "format:json" \
+  http://127.0.0.1:8030/api/test_variant/github_events/_stream_load
+```
+
+함께 참조: `https://doris.apache.org/docs/dev/data-operate/import/complex-types/variant`
+
+데이터 적재 후 `SELECT count(*)`로 확인하거나 `SELECT * ... LIMIT 1`로 샘플을 조회하세요. 높은 처리량의 데이터 적재에는 RANDOM 버킷팅을 사용하고 Group Commit을 활성화하는 것이 좋습니다.
+
+## 출력 {#output}
+
+VARIANT 컬럼을 읽을 때 반환되는 JSON 텍스트는 입력한 JSON 텍스트와 바이트 단위로 동일하지 않습니다. JSON 객체 내부의 키는 입력 JSON에 나타난 순서와 관계없이 정렬된 순서(사전식 순서)로 출력됩니다.
+
+```sql
+INSERT INTO variant_tbl VALUES
+  (2, '{ "b": 2, "a": 1, "c": { "y": 20, "x": 10 } }');
+
+SELECT v FROM variant_tbl WHERE k = 2;
++-----------------------------------+
+| v                                 |
++-----------------------------------+
+| {"a":1,"b":2,"c":{"x":10,"y":20}} |
++-----------------------------------+
+```
+
+정렬은 모든 수준에 적용됩니다. 최상위 키는 `a`, `b`, `c` 순서가 되고, 중첩 객체의 키는 `x`, `y` 순서가 됩니다.
+
+## 지원되는 연산 및 CAST 규칙 {#supported-operations-and-cast-rules}
+
+- VARIANT는 다른 타입과 직접 비교하거나 연산할 수 없으며, 두 VARIANT 간 비교도 지원되지 않습니다.
+- 비교, 필터링, 집계, 정렬을 수행하려면 하위 경로를 명시적 또는 암시적으로 구체적인 타입으로 CAST하세요.
+
+```sql
+-- Explicit CAST
+SELECT CAST(v['arr'] AS ARRAY<TEXT>) FROM tbl;
+SELECT * FROM tbl WHERE CAST(v['decimal'] AS DECIMAL(27, 9)) = 1.111111111;
+SELECT * FROM tbl WHERE CAST(v['date'] AS DATE) = '2021-01-02';
+
+-- Implicit CAST
+SELECT * FROM tbl WHERE v['bool'];
+SELECT * FROM tbl WHERE v['str'] MATCH 'Doris';
+```
+
+- VARIANT 자체는 ORDER BY, GROUP BY, JOIN KEY 또는 집계 함수 인수로 직접 사용할 수 없습니다. 대신 하위 경로를 CAST하세요.
+- 문자열은 VARIANT로 암시적으로 변환할 수 있습니다.
+
+| VARIANT         | 명시적 변환 가능 | 암시적 변환 가능 |
+| --------------- | -------- | --------- |
+| `ARRAY`         | ✔        | ❌        |
+| `BOOLEAN`       | ✔        | ✔         |
+| `DATE/DATETIME` | ✔        | ✔         |
+| `FLOAT`         | ✔        | ✔         |
+| `IPV4/IPV6`     | ✔        | ✔         |
+| `DECIMAL`       | ✔        | ✔         |
+| `MAP`           | ❌        | ❌        |
+| `TIMESTAMP`     | ✔        | ✔         |
+| `VARCHAR`       | ✔        | ✔         |
+| `JSON`          | ✔        | ✔         |
+
+## 와이드 컬럼 {#wide-columns}
+
+적재한 데이터에 서로 다른 JSON 키가 많으면 Subcolumnization으로 생성되는 하위 컬럼 수가 빠르게 증가할 수 있습니다. 규모가 커지면 메타데이터 비대화, 쓰기/병합 비용 증가, 쿼리 속도 저하가 발생할 수 있습니다. VARIANT는 하위 컬럼이 너무 많은 “와이드 컬럼” 문제를 해결하기 위해 **희소 컬럼**과 **DOC 인코딩**이라는 두 가지 메커니즘을 제공합니다.
+
+워크로드에 맞는 선택 방법은 [Variant 워크로드 가이드](./variant-workload-guide)를 참조하세요. 이 섹션에서는 메커니즘과 관련 속성만 설명합니다.
+
+참고: 이 두 메커니즘은 상호 배타적입니다. DOC 인코딩을 활성화하면 희소 컬럼이 비활성화되며, 그 반대도 마찬가지입니다.
+
+### 희소 컬럼 {#sparse-columns}
+
+**동작 방식**
+
+- 시스템은 NULL이 아닌 값의 비율 / 희소성을 기준으로 경로의 순위를 매깁니다. 빈도가 높은(희소성이 낮은) 경로는 Subcolumnization을 거쳐 독립적인 하위 컬럼으로 저장되고, 나머지 빈도가 낮은(희소한) 경로는 병합되어 희소 컬럼에 저장됩니다. 추출되는 하위 컬럼의 최대 수는 `variant_max_subcolumns_count`로 제어합니다.
+- Schema Template에 선언된 경로는 기본적으로 희소 컬럼으로 이동하지 않습니다. 타입이 지정된 경로도 희소 컬럼으로 이동할 수 있도록 허용하려면 `variant_enable_typed_paths_to_sparse`를 설정하세요.
+- 희소 컬럼은 샤딩을 지원합니다. 희소 하위 경로를 여러 희소 컬럼에 분산하여 컬럼별 읽기 오버헤드를 줄이고 읽기 효율을 높입니다. 물리적으로 저장할 희소 컬럼 수는 `variant_sparse_hash_shard_count`로 지정합니다.
+
+**참고 사항**
+
+- 대부분의 키에서 NULL이 아닌 값의 비율이 비슷하면(희소성 차이가 작으면) 실제로 희소한 경로를 식별하기 어려워 희소 컬럼의 효과가 줄어듭니다.
+- `variant_max_subcolumns_count`의 기본값은 `2048`이며, 대부분의 워크로드에 충분합니다. 추출되는 하위 컬럼을 더 많이 미리 할당하려는 목적으로 이 값을 크게 늘리지 마세요. 워크로드에 대규모 Subcolumnization이 꼭 필요하다면 <a href="./variant-workload-guide#doc-mode-template">DOC 모드</a>를 권장합니다. 실제 상한은 여전히 `10000` 이하로 유지하는 것이 좋습니다.
+- `variant_sparse_hash_shard_count`는 대략 “희소 경로 수 / 128”로 추정할 수 있습니다. 예를 들어 전체 JSON 키가 약 10,000개이고 `variant_max_subcolumns_count = 2000`이면 희소 경로는 약 8000개이므로, `variant_sparse_hash_shard_count`는 `8000/128` 정도로 시작할 수 있습니다.
+
+### DOC 인코딩 (DOC 모드) {#doc-encoding-doc-mode}
+
+**동작 방식**
+
+- 경로 기반 쿼리를 위해 경로에 Subcolumnization을 수행할 수 있으며, 전체 JSON 문서를 효율적으로 반환하기 위해 원본 JSON을 저장 필드로 추가 저장합니다.
+- DOC 인코딩은 샤딩을 지원합니다. 원본 JSON을 여러 컬럼으로 나누어 저장하고, 전체 JSON을 쿼리할 때 다시 조합합니다. DOC 샤드 수는 `variant_doc_hash_shard_count`로 지정합니다.
+- 소규모 배치 쓰기에서는 Subcolumnization을 건너뛰고 이후 병합 시점으로 미룰 수 있습니다. 이는 `variant_doc_materialization_min_rows`로 제어합니다. 예를 들어 `variant_doc_materialization_min_rows = 10000`이면 10,000행 미만의 쓰기에서는 원본 JSON만 저장하며, 해당 배치에 Subcolumnization을 수행하지 않습니다.
+- 매우 넓은 워크로드에서는 Subcolumnization 규모가 일만 개의 하위 컬럼에 가까워질 때 DOC 모드가 더 안정적인 선택입니다. 기본적인 즉시 Subcolumnization과 비교하면 컴팩션 메모리는 약 삼분의 이만큼 줄어들 수 있고, 희소한 와이드 컬럼의 데이터 적재 처리량은 약 5-10x 향상될 수 있습니다.
+- `VARIANT` 컬럼이 매우 넓고 쿼리가 전체 문서를 자주 읽는 경우, DOC 모드는 다수의 하위 컬럼에서 문서를 재구성하는 방식에 비해 `SELECT variant_col` 성능을 수십 배 이상 높일 수 있습니다.
+
+**참고 사항**
+
+- DOC 모드에는 `variant_enable_doc_mode = true`가 필요합니다.
+- DOC 모드에서는 Schema Template으로 타입을 선언한 경로가 숫자, 문자열, 배열 타입으로 제한됩니다.
+- `variant_doc_hash_shard_count`는 대략 “전체 JSON 키 수 / 128”로 추정할 수 있습니다.
+
+전체 속성 목록은 아래 “설정” 섹션을 참조하세요.
+
+## 제한 사항 {#limitations}
+
+- **와이드 테이블 최적화**: `VARIANT` 타입으로 생성되는 동적 하위 컬럼이 많은 와이드 테이블(예: 컬럼 수가 2000개를 초과하는 경우)에서는 `"storage_format" = "V3"`를 테이블 `PROPERTIES`에 지정하여 **Storage Format V3**를 활성화하는 것을 적극 권장합니다. 이 형식은 컬럼 메타데이터를 Segment Footer에서 분리하여 파일 열기 속도를 높이고 메모리 오버헤드를 줄입니다.
+- JSON 키 길이는 255 이하여야 합니다.
+- JSON 문자열을 VARIANT로 명시적으로 변환하려면 [`PARSE_TO_VARIANT`](../../../sql-functions/scalar-functions/variant-functions/parse-to-variant.md)와 [`TRY_PARSE_TO_VARIANT`](../../../sql-functions/scalar-functions/variant-functions/try-parse-to-variant.md)(4.1.4부터 지원)를 사용하세요. 전자는 파싱에 실패하면 오류를 보고하고, 후자는 NULL을 반환한다는 차이가 있습니다.
+- 기본 키 또는 정렬 키로 사용할 수 없습니다.
+- 다른 타입 내부에 중첩할 수 없습니다(예: `Array<Variant>`, `Struct<Variant>`).
+- DOC 모드가 아니면 전체 VARIANT 컬럼을 읽을 때 모든 하위 경로를 스캔합니다. 매우 넓은 컬럼에서는 DOC 모드를 활성화하지 않은 상태로 직접 `SELECT variant_col`을 사용하는 것을 일반적으로 권장하지 않습니다. 컬럼에 하위 경로가 많으면 `LIKE`와 같은 전체 객체 검색을 위해 원본 JSON 문자열을 추가 STRING/JSONB 컬럼에 저장하는 방법을 고려하세요.
+
+```sql
+CREATE TABLE example_table (
+  id INT,
+  data_variant VARIANT
+);
+SELECT * FROM example_table WHERE data_variant LIKE '%doris%';
+
+-- Better: keep the original JSON string for whole-object matching
+CREATE TABLE example_table (
+  id INT,
+  data_string STRING,
+  data_variant VARIANT
+);
+SELECT * FROM example_table WHERE data_string LIKE '%doris%';
+```
+
+## 설정 {#configuration}
+
+3.1+부터 VARIANT는 컬럼의 타입 수준 속성을 지원합니다.
+
+```sql
+CREATE TABLE example_table (
+  id INT,
+  data_variant VARIANT<
+      'path_1' : INT,
+      'path_2' : STRING,
+      properties(
+          'variant_max_subcolumns_count' = '2048',
+          'variant_enable_typed_paths_to_sparse' = 'true',
+          'variant_sparse_hash_shard_count' = '64'
+      )
+  >
+);
+```
+
+<table>
+<tr><td>속성</td><td>설명</td></tr>
+<tr><td>`variant_max_subcolumns_count`</td><td>Subcolumnization을 수행할 수 있는 최대 경로 수입니다. 임계값을 초과하면 새로운 경로가 공유 데이터 구조에 저장될 수 있습니다. 기본값은 2048(권장)이며, 대부분의 워크로드에 충분합니다. 너무 크게 설정하지 마세요. 워크로드에 매우 큰 규모의 하위 컬럼 추출이 꼭 필요하다면 <a href="./variant-workload-guide#doc-mode-template">DOC 모드</a>를 권장합니다. 0은 제한 없음을 의미하며, 10000을 초과하지 마세요.</td></tr>
+<tr><td>`variant_enable_typed_paths_to_sparse`</td><td>기본적으로 타입이 지정된 경로는 항상 Subcolumnization 대상이 됩니다(또한 `variant_max_subcolumns_count`에 포함되지 않습니다). `true`로 설정하면 타입이 지정된 경로도 임계값 계산에 포함되며 공유 구조로 이동할 수 있습니다.</td></tr>
+<tr><td>`variant_sparse_hash_shard_count`</td><td>희소 컬럼의 샤드 수입니다. 희소 하위 경로를 여러 희소 컬럼에 분산하여 읽기 성능을 높입니다. 기본값은 1이며, 희소 하위 경로 수에 따라 조정하세요.</td></tr>
+</table>
+
+```sql
+CREATE TABLE example_table (
+  id INT,
+  data_variant VARIANT<
+      'path_1' : INT,
+      'path_2' : STRING,
+      properties(
+          'variant_enable_doc_mode' = 'true',
+          'variant_doc_materialization_min_rows' = '10000',
+          'variant_doc_hash_shard_count' = '64'
+      )
+  >
+);
+```
+
+<table>
+<tr><td>속성</td><td>설명</td></tr>
+<tr><td>`variant_enable_doc_mode`</td><td>DOC 인코딩 모드를 활성화합니다. `true`이면 전체 JSON 문서를 빠르게 반환하기 위해 원본 JSON을 저장 필드로 저장합니다. DOC 모드와 희소 컬럼은 상호 배타적입니다. 기본값은 `false`입니다.</td></tr>
+<tr><td>`variant_doc_materialization_min_rows`</td><td>DOC 모드에서 Subcolumnization을 수행하기 위한 최소 행 수 임계값입니다. 행 수가 이 값보다 적으면 원본 JSON만 저장합니다. 컴팩션으로 파일을 병합하여 임계값에 도달하면 Subcolumnization을 수행합니다. 소규모 배치 쓰기의 오버헤드를 줄이는 데 도움이 됩니다.</td></tr>
+<tr><td>`variant_doc_hash_shard_count`</td><td>DOC 인코딩의 샤드 수입니다. 원본 JSON을 지정된 수의 컬럼으로 나누어 저장하고, 전체 JSON을 쿼리할 때 다시 조합합니다. 기본값은 64이며, JSON 크기와 동시성에 따라 조정하세요.</td></tr>
+</table>
+
+한계에 도달했을 때의 동작과 튜닝 권장 사항:
+
+1. 임계값을 초과하면 새로운 경로는 공유 구조에 기록됩니다. Rowset 병합 중에도 일부 경로가 공유 구조로 회수될 수 있습니다.
+2. 시스템은 NULL이 아닌 값의 비율과 접근 빈도가 높은 경로를 Subcolumnization 대상으로 우선 유지합니다.
+3. Subcolumnization 대상 경로가 10,000개에 가까워지면 강력한 하드웨어가 필요합니다(노드당 ≥128G RAM, ≥32C 권장). 워크로드가 이미 이 범위에 가깝다면 DOC 모드를 먼저 평가하는 것이 좋습니다.
+4. 데이터 적재 튜닝: 클라이언트의 `batch_size`를 적절히 늘리거나 Group Commit을 사용하세요(필요에 따라 `group_commit_interval_ms`/`group_commit_data_bytes`를 늘리세요).
+5. 파티션 프루닝이 필요하지 않으면 RANDOM 버킷팅과 단일 tablet 데이터 적재 활성화를 고려하여 컴팩션 쓰기 증폭을 줄이세요.
+6. BE 튜닝 설정: `max_cumu_compaction_threads`(≥8), `vertical_compaction_num_columns_per_group=500`(수직 컴팩션 성능을 높이지만 메모리 사용량 증가), `segment_cache_memory_percentage=20`(메타데이터 캐시 효율 향상).
+7. Compaction Score를 관찰하세요. 계속 상승하면 컴팩션이 뒤처지고 있다는 뜻이므로 데이터 적재 부하를 줄이세요.
+8. VARIANT에서 대규모 `SELECT *`를 피하고 `SELECT v['path']`와 같이 필요한 항목만 조회하세요.
+
+참고: Stream Load 오류 `[DATA_QUALITY_ERROR]Reached max column size limit 2048`이 발생하면(2.1.x 및 3.0.x에서만 발생), 병합된 tablet 스키마가 컬럼 수 한도에 도달했다는 의미입니다. `variant_max_merged_tablet_schema_size`를 늘릴 수 있습니다(4096 초과는 권장하지 않으며, 강력한 하드웨어가 필요합니다).
+
+## 컬럼 수 및 타입 확인 {#inspect-number-of-columns-and-types}
+
+방법 1: `variant_type`으로 행별 스키마를 확인합니다(더 정확하지만 비용이 높음).
+
+```sql
+SELECT variant_type(v) FROM variant_tbl;
+```
+
+방법 2: 확장된 `DESC`로 Subcolumnization을 통해 추출된 하위 경로를 표시합니다.
+
+```sql
+SET describe_extend_variant_column = true;
+DESC variant_tbl;
+```
+
+``` sql
+DESCRIBE ${table_name} PARTITION ($partition_name);
+```
+
+두 방법을 함께 사용하세요. 방법 1은 정확하고, 방법 2는 효율적입니다.
+
+## JSON 타입과 비교 {#compared-with-json-type}
+
+- 저장: JSON은 JSONB(행 지향)로 저장됩니다. VARIANT는 쓰기 시 Subcolumnization을 수행합니다(더 높은 압축률, 더 작은 크기).
+- 쿼리: JSON은 파싱이 필요합니다. VARIANT는 컬럼을 직접 스캔하므로 일반적으로 훨씬 빠릅니다.
+
+ClickBench(쿼리 43개):
+- 저장: VARIANT는 JSON 대비 공간을 ~65% 절약합니다.
+- 쿼리: VARIANT는 JSON보다 8x+ 빠르며, 사전 정의된 정적 컬럼에 가까운 성능을 보입니다.
+
+**저장 공간**
+
+| 타입                | 크기       |
+| ------------------- | ---------- |
+| 사전 정의된 컬럼  | 12.618 GB  |
+| VARIANT             | 12.718 GB  |
+| JSON                | 35.711 GB  |
+
+**~65% 공간 절약**
+
+| 실행             | 사전 정의된 컬럼 | VARIANT | JSON            |
+| ----------------| ---------- | ------- | --------------- |
+| 첫 번째 (콜드)    | 233.79s    | 248.66s | 대부분 시간 초과  |
+| 두 번째 (핫)    | 86.02s     | 94.82s  | 789.24s         |
+| 세 번째 (핫)     | 83.03s     | 92.29s  | 743.69s         |
+
+## FAQ {#faq}
+
+1. VARIANT의 `null`과 SQL의 `NULL`은 다른가요?
+   - 아니요. 둘은 동일합니다.
+2. 쿼리/인덱스가 작동하지 않는 이유는 무엇인가요?
+   - 경로를 올바른 타입으로 CAST했는지, 타입 충돌로 인해 JSONB로 승격되었는지, 하위 경로가 아닌 전체 VARIANT에 인덱스가 적용될 것으로 잘못 예상하고 있는지 확인하세요.
+3. VARIANT 컬럼에 쓸 때 DECIMAL의 정밀도가 손실되는 이유는 무엇인가요?
+   - VARIANT 컬럼에 쓸 때 하위 컬럼의 타입은 DECIMAL로 추론되지 않습니다. 숫자 값은 DOUBLE로 저장되므로 소수점 이하 뒷자리가 손실될 수 있습니다. Schema Template으로 하위 경로를 DECIMAL로 선언하더라도(예: `pm25 VARIANT<'xxx': DECIMAL(6, 2)>`) 정밀도가 완전히 보장되지는 않습니다. 쓰기 경로에서 값을 먼저 DOUBLE로 파싱한 후 DECIMAL로 변환하기 때문입니다. JSON 값을 문자열로 작성하고(예: `'{"num": "12.345"}'`) 이에 맞는 Schema Template DECIMAL 선언(예: `DECIMAL(9, 3)`)을 함께 지정하면, 쓰기 시 문자열을 DECIMAL로 직접 파싱하므로 정밀도가 유지됩니다.
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/variant-workload-guide.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/variant-workload-guide.md
new file mode 100644
index 00000000000..e69d471b289
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/semi-structured/variant-workload-guide.md
@@ -0,0 +1,315 @@
+---
+{
+    "title": "VARIANT 워크로드 가이드",
+    "language": "ko",
+    "description": "VARIANT를 언제 사용해야 하는지, 기본 모드, 희소 모드, DOC 모드, Schema Template 중 무엇을 선택해야 하는지, 설정을 어디서부터 시작해야 하는지 안내합니다."
+}
+---
+
+## 개요 {#overview}
+
+`VARIANT`는 반정형 JSON을 저장하고 자주 사용하는 경로에 Subcolumnization을 적용합니다.
+
+새로운 `VARIANT` 워크로드의 데이터 모델을 결정할 때 이 가이드를 활용하세요. 다음과 같은 질문에 답하는 데 도움이 됩니다.
+
+- 이 워크로드에는 `VARIANT`와 정적 컬럼 중 무엇을 사용해야 할까요?
+- JSON의 폭이 매우 넓다면 기본 동작, 희소 컬럼, DOC 모드 중 무엇으로 시작해야 할까요?
+- 어떤 설정은 기본값으로 두고, 어떤 설정부터 변경해야 할까요?
+
+이미 `VARIANT`를 사용하기로 결정했고 구문이나 타입 규칙만 필요하다면 [VARIANT](./VARIANT)를 참조하세요. 바로 실행할 수 있는 최소한의 데이터 적재 예제가 필요하다면 [Variant 데이터 적재](../../../../data-operate/import/complex-types/variant)를 참조하세요.
+
+:::tip VARIANT를 선택하는 이유
+`VARIANT`는 JSON의 유연성을 유지하면서도 Doris가 자주 사용하는 경로에 Subcolumnization을 적용할 수 있게 합니다. 따라서 문서 전체의 스키마를 미리 고정하지 않아도 일반적인 필터링, 집계, 경로별 인덱스가 효율적으로 작동합니다. 폭이 매우 넓은 JSON에서도 스토리지 계층의 최적화 덕분에 훨씬 많은 경로에 Subcolumnization을 실용적으로 적용할 수 있습니다.
+:::
+
+## VARIANT가 적합한 경우 {#when-variant-fits}
+
+다음 조건 대부분에 해당한다면 일반적으로 `VARIANT`가 적합합니다.
+
+- 입력이 JSON 또는 다른 반정형 데이터이며, 필드가 시간이 지나면서 바뀝니다.
+- 쿼리가 모든 행의 모든 필드를 읽기보다 일부 핫 경로에 주로 접근합니다.
+- 컬럼형 분석 성능을 유지하면서 스키마 유연성을 확보하려고 합니다.
+- 일부 경로에는 인덱스가 필요하지만, 나머지 많은 경로는 동적으로 유지해도 됩니다.
+
+다음 조건이 더 중요하다면 정적 컬럼을 우선 고려하세요.
+
+- 스키마가 안정적이고 미리 알려져 있습니다.
+- 핵심 필드가 조인 키, 정렬 키 또는 타입을 엄격하게 관리하는 컬럼으로 자주 사용됩니다.
+- 주된 요구 사항이 경로별 분석이 아니라 원본 JSON의 보관입니다.
+
+## 먼저 확인할 네 가지 질문 {#four-questions-first}
+
+설정을 변경하기 전에 다음 네 가지 질문에 답해 보세요.
+
+### 1. 핫 경로가 명확한가요? {#1-are-there-clear-hot-paths}
+
+쿼리가 같은 JSON 경로에 반복해서 접근한다면 Doris는 해당 경로에 Subcolumnization을 계속 적용할 수 있습니다. 이런 경우에 `VARIANT`의 이점이 가장 큽니다.
+
+### 2. 일부 경로에 고정된 타입이나 안정적인 인덱스가 필요한가요? {#2-do-a-few-paths-need-fixed-types-or-stable-indexes}
+
+그렇다면 해당 경로에만 Schema Template을 사용하세요. Schema Template은 비즈니스상 중요한 소수의 필드를 위한 기능이며, 문서 전체를 정의하기 위한 기능은 아닙니다.
+
+### 3. 실제로 와이드 JSON 문제가 발생하고 있나요? {#3-is-this-really-becoming-wide-json}
+
+경로 수가 계속 늘어나 메타데이터나 컴팩션에 부담을 주거나, 눈에 띄는 쿼리 오버헤드를 유발하기 시작하면 와이드 JSON 문제가 발생한 것입니다.
+
+### 4. 와이드 JSON에서 핫 경로 분석과 전체 문서 반환 중 무엇이 더 중요한가요? {#4-for-wide-json-what-matters-more-hot-path-analytics-or-whole-document-return}
+
+- 주된 활용이 여전히 핫 필드의 경로 기반 필터링, 집계, 인덱싱이라면 희소 컬럼을 우선 고려하세요.
+- 주된 활용이 데이터 적재 효율이나 전체 문서 반환이라면 DOC 모드를 우선 고려하세요.
+
+## 핵심 개념 {#key-concepts}
+
+아래 스토리지 모드를 읽기 전에 다음 용어를 이해해 두세요. 각 용어를 2-3줄로 설명합니다. 구현 세부 사항은 [VARIANT](./VARIANT)를 참조하세요.
+
+**Subcolumnization.** 데이터를 `VARIANT` 컬럼에 쓸 때 Doris가 JSON 경로를 자동으로 발견하고 핫 경로를 독립적인 컬럼형 서브컬럼으로 추출하여 효율적인 분석을 지원하는 기능입니다.
+
+<img src="/images/variant/variant-default-storage.png" alt="기본 VARIANT: 자동 서브컬럼 추출" width="720" />
+
+**Schema Template.** 선택한 경로를 안정적인 타입으로 고정하는 `VARIANT` 컬럼의 선언입니다. 타입, 인덱싱 가능 여부, 동작의 예측 가능성을 유지해야 하는 핵심 비즈니스 필드에 사용하세요. 가능한 모든 경로를 나열하려고 하지 마세요.
+
+**와이드 JSON.** 서로 다른 경로의 수가 계속 늘어나 메타데이터 크기, 쓰기 비용, 컴팩션 비용 또는 쿼리 비용을 증가시키기 시작하면 와이드 JSON 문제가 발생한 것입니다.
+
+**희소 컬럼.** 와이드 JSON에서 핫 경로와 콜드 경로가 명확하게 나뉘는 경우, 희소 컬럼은 핫 경로에 Subcolumnization을 유지하면서 콜드 경로인 롱테일 경로를 공유 희소 스토리지에 저장합니다. 희소 스토리지는 여러 물리 컬럼에 걸친 샤딩을 지원하여 읽기 병렬성을 높입니다.
+
+<img src="/images/variant/variant-sparse-storage.png" alt="희소 컬럼: 핫/콜드 경로 분리" width="720" />
+
+위 그림처럼 `user_id`, `page`와 같은 핫 경로는 분석 성능을 온전히 유지하는 독립적인 컬럼형 서브컬럼으로 남고, 수천 개의 롱테일 경로는 공유 희소 스토리지에 모입니다. 이 임계값은 `variant_max_subcolumns_count`로 제어합니다.
+
+**희소 샤딩.** 롱테일 경로 수가 매우 많으면 단일 희소 컬럼이 읽기 병목이 될 수 있습니다. 희소 샤딩은 해시를 기준으로 롱테일 경로를 여러 물리 컬럼에 분산하여(`variant_sparse_hash_shard_count`) 병렬로 스캔할 수 있게 합니다.
+
+<img src="/images/variant/variant-sparse-sharding.png" alt="희소 샤딩: 롱테일 경로 병렬 읽기" width="720" />
+
+**DOC 모드.** 쓰기 시점의 Subcolumnization을 지연하고, 원본 JSON을 맵 형식의 저장 필드인 **doc map**에 추가로 저장합니다. 저장 공간을 더 사용하는 대신 빠른 데이터 적재와 효율적인 전체 문서 반환을 제공합니다. Subcolumnization은 이후 컴팩션 중에 수행됩니다.
+
+<img src="/images/variant/variant-doc-mode.png" alt="DOC 모드: 추출 지연 + 빠른 문서 반환" width="700" />
+
+위 그림처럼 쓰기 시점에는 JSON을 Doc Store에 원래 형태 그대로 보존하여 빠르게 적재합니다. 서브컬럼은 이후 컴팩션 중에 추출합니다. 읽기 시점에 경로 기반 쿼리(예: `SELECT v['user_id']`)는 구체화된 서브컬럼에서 컬럼형 스토리지의 성능을 온전히 활용하여 읽고, 전체 문서 쿼리(`SELECT v`)는 서브컬럼에서 문서를 재구성하지 않고 Doc Store에서 직접 읽습니다.
+
+DOC 모드에는 쿼리 대상 경로의 구체화 여부에 따라 세 가지 읽기 경로가 있습니다.
+
+<img src="/images/variant/variant-doc-mode-readpaths.png" alt="DOC 모드: 읽기 경로 상세" width="720" />
+
+- **DOC Materialized**: 쿼리 대상 경로가 이미 서브컬럼으로 추출된 상태입니다(컴팩션 이후 또는 `variant_doc_materialization_min_rows` 조건 충족 시). 기본 VARIANT와 동일하게 컬럼형 스토리지의 성능을 온전히 활용하여 읽습니다.
+- **DOC Map**: 쿼리 대상 경로가 아직 구체화되지 않은 상태입니다. 쿼리가 doc map 전체를 스캔하여 값을 찾는 방식으로 폴백하므로, 와이드 JSON에서는 훨씬 느립니다.
+- **DOC Map (샤딩 적용)**: 동일한 폴백 방식이지만, `variant_doc_hash_shard_count`를 통해 doc map을 여러 물리 컬럼에 분산하므로 병렬 스캔이 가능하고 값을 훨씬 빠르게 복원할 수 있습니다.
+
+**Storage Format V3.** 컬럼 메타데이터를 세그먼트 푸터에서 분리합니다. 수천 개의 서브컬럼이 있을 때 발생하는 메타데이터 병목을 없애므로, 모든 `VARIANT` 테이블에 권장되며 특히 와이드 JSON에 유용합니다.
+
+## 권장 선택 절차 {#recommended-decision-path}
+
+<img src="/images/variant/variant-decision-flowchart.png" alt="VARIANT 모드 선택 절차" width="520" />
+
+## 스토리지 모드 {#storage-modes}
+
+아래 테이블에서 시작할 모드를 고른 다음 해당 절을 읽어 보세요.
+
+| | 일반적인 시나리오 | 권장 모드 | 주요 설정 |
+|---|---|---|---|
+| **A** | 이벤트 로그, 감사 로그 | 기본 VARIANT + V3 | 기본값 유지 |
+| **B** | 광고 / 텔레메트리 / 사용자 프로필(폭이 넓고 핫 경로가 적음) | 희소 모드 + V3 | `variant_max_subcolumns_count`, `variant_sparse_hash_shard_count` |
+| **C** | 모델 출력 / 트레이스 / 보관 데이터(데이터 적재 우선 또는 전체 문서 반환) | DOC 모드 + V3 | `variant_enable_doc_mode`, `variant_doc_materialization_min_rows` |
+| **D** | 주문 / 결제 / 기기(핵심 경로에 안정적인 타입이 필요함) | Schema Template + A 또는 B | 핵심 경로만 정의 |
+
+### 기본 모드 {#default-mode}
+
+대부분의 새로운 `VARIANT` 워크로드에서 가장 안전한 출발점입니다.
+
+대표적인 예는 쿼리가 몇 가지 익숙한 경로에 반복해서 접근하는 이벤트 로그나 감사 데이터입니다.
+
+```sql
+CREATE TABLE IF NOT EXISTS event_log (
+    ts DATETIME NOT NULL,
+    event_id BIGINT NOT NULL,
+    event_type VARCHAR(64),
+    payload VARIANT
+)
+DUPLICATE KEY(`ts`, `event_id`)
+DISTRIBUTED BY HASH(`event_id`) BUCKETS 16
+PROPERTIES (
+    "replication_num" = "1",
+    "storage_format" = "V3"
+);
+```
+
+워크로드가 희소 컬럼이나 DOC 모드를 도입할 만큼 넓은지 아직 확실하지 않고, 주된 활용이 여전히 몇 가지 공통 경로에 대한 필터링, 집계, 그룹화인 경우 사용하세요.
+
+유의 사항:
+- 경로 증가로 이미 부담이 발생하고 있는 경우가 아니라면 `variant_max_subcolumns_count`를 미리 높이지 마세요.
+- JSON의 폭이 넓지 않다면 희소 컬럼이나 DOC 모드를 활성화해도 이점 없이 복잡성만 늘어납니다.
+
+### 희소 모드 {#sparse-mode}
+
+데이터의 폭이 넓지만 대부분의 쿼리가 여전히 소수의 핫 경로에 집중한다면 희소 컬럼을 선택하세요.
+
+대표적인 예는 선택적 속성이 수천 개 있지만 정기적으로 쿼리하는 속성은 수십 개뿐인 광고, 텔레메트리 또는 프로필 JSON입니다.
+
+```sql
+CREATE TABLE IF NOT EXISTS telemetry_wide (
+    ts DATETIME NOT NULL,
+    device_id BIGINT NOT NULL,
+    attributes VARIANT<
+        'device_type' : STRING,
+        'region' : STRING,
+        properties(
+            'variant_max_subcolumns_count' = '2048',
+            'variant_sparse_hash_shard_count' = '64'
+        )
+    >
+)
+DUPLICATE KEY(`ts`, `device_id`)
+DISTRIBUTED BY HASH(`device_id`) BUCKETS 32
+PROPERTIES (
+    "replication_num" = "1",
+    "storage_format" = "V3"
+);
+```
+
+전체 키 수가 매우 많지만 주된 워크로드가 여전히 경로 기반 필터링, 집계, 인덱싱인 경우 사용하세요.
+
+유의 사항:
+- 핫 경로 분석이 병목이라면 DOC 모드부터 도입하지 마세요.
+- `variant_max_subcolumns_count`의 기본값은 `2048`이며, 대부분의 워크로드에서 자동 Subcolumnization을 시작하기에 이미 적절한 값입니다. 사실상 모든 경로에 Subcolumnization이 적용될 정도로 크게 설정하지 마세요. 워크로드에 정말로 매우 많은 추출 서브컬럼이 필요하다면 [DOC 모드](#doc-mode-template)를 우선 고려하세요.
+
+### DOC 모드 {#doc-mode-template}
+
+경로 기반 분석 최적화보다 전체 JSON 문서 반환이나 데이터 적재 오버헤드 최소화가 더 중요하다면 DOC 모드를 선택하세요.
+
+대표적인 예는 완전한 데이터 형태로 반환하는 경우가 많은 모델 응답, 트레이스 스냅샷 또는 보관된 JSON 문서입니다.
+
+DOC 모드는 다음과 같은 경우에 도움이 됩니다.
+
+- Subcolumnization 규모가 매우 커지면(경로 수가 10,000개에 가까워지면) 하드웨어 요구 사항이 빠르게 증가합니다. 이 규모에서는 DOC 모드가 더 안정적인 선택입니다.
+- 기본 모드에서 즉시 Subcolumnization을 수행할 때와 비교하면 컴팩션 메모리 사용량이 약 삼분의 이 감소할 수 있습니다.
+- 희소한 와이드 컬럼을 적재하는 워크로드에서는 처리량이 약 5–10× 향상될 수 있습니다.
+- 쿼리가 전체 `VARIANT` 값(`SELECT variant_col`)을 읽을 때 DOC 모드는 수천 개의 서브컬럼에서 문서를 재구성하는 과정을 생략하므로, 속도를 수 자릿수 수준으로 높일 수 있습니다.
+
+**시작하기:**
+
+```sql
+CREATE TABLE IF NOT EXISTS trace_archive (
+    ts DATETIME NOT NULL,
+    trace_id VARCHAR(64) NOT NULL,
+    span VARIANT<
+        'service_name' : STRING,
+        properties(
+            'variant_enable_doc_mode' = 'true',
+            'variant_doc_materialization_min_rows' = '10000',
+            'variant_doc_hash_shard_count' = '64'
+        )
+    >
+)
+DUPLICATE KEY(`ts`, `trace_id`)
+DISTRIBUTED BY HASH(`trace_id`) BUCKETS 32
+PROPERTIES (
+    "replication_num" = "1",
+    "storage_format" = "V3"
+);
+```
+
+데이터 적재 처리량이 최우선이거나, 워크로드에서 전체 JSON 문서를 자주 반환해야 하거나, 폭이 매우 넓은 컬럼을 `SELECT variant_col`로 자주 읽는 경우 사용하세요.
+
+유의 사항:
+- DOC 모드가 모든 와이드 JSON 워크로드의 기본 해법은 아닙니다. 핫 경로 분석이 주를 이룬다면 대체로 희소 컬럼이 더 적합합니다.
+- DOC 모드와 희소 컬럼은 상호 배타적이므로 동시에 활성화할 수 없습니다.
+
+### Schema Template {#schema-template}
+
+소수의 경로에 안정적인 타입, 안정적인 동작 또는 경로별 인덱스가 필요하다면 Schema Template을 선택하세요.
+
+대표적인 예는 비즈니스상 중요한 몇 가지 경로가 정해진 타입과 검색 가능한 상태를 유지해야 하는 주문, 결제 또는 기기 데이터입니다.
+
+```sql
+CREATE TABLE IF NOT EXISTS order_events (
+    ts DATETIME NOT NULL,
+    order_id BIGINT NOT NULL,
+    detail VARIANT<
+        'status' : STRING,
+        'amount' : DECIMAL(18, 2),
+        'currency' : STRING
+    >,
+    INDEX idx_status(detail) USING INVERTED PROPERTIES("field_pattern" = "status")
+)
+DUPLICATE KEY(`ts`, `order_id`)
+DISTRIBUTED BY HASH(`order_id`) BUCKETS 16
+PROPERTIES (
+    "replication_num" = "1",
+    "storage_format" = "V3"
+);
+```
+
+비즈니스상 중요한 필드가 소수이고, 해당 경로에 더 엄격한 타입 지정이나 경로별 인덱스 전략이 필요한 경우 사용하세요. 필요에 따라 Schema Template을 희소 컬럼이나 기본 `VARIANT`와 함께 사용하세요.
+
+유의 사항:
+- JSON 스키마 전체를 정적 템플릿으로 만들지 마세요. 그러면 `VARIANT`를 사용하는 의미가 사라집니다.
+- Schema Template에는 핵심 경로만 포함하고 나머지는 동적으로 유지하세요.
+
+## 성능 {#performance}
+
+아래 차트는 경로가 10K개인 와이드 컬럼 데이터셋에서 단일 경로를 추출하는 시간을 비교합니다(200K개 행, 키 하나 추출, CPU 16개, 3회 실행의 중앙값).
+
+<img src="/images/variant/variant-bench-query-time.svg" alt="와이드 컬럼의 단일 경로 추출: 쿼리 시간" width="720" />
+
+| 모드 | 쿼리 시간 | 최대 메모리 |
+|---|---:|---:|
+| DOC Materialized | 76 ms | 1 MiB |
+| VARIANT 기본 모드 | 76 ms | 1 MiB |
+| DOC Map (샤딩 적용) | 148 ms | 1 MiB |
+| JSONB | 887 ms | 32 GiB |
+| DOC Map | 2,533 ms | 1 MiB |
+| MAP\<STRING,STRING\> | 2,800 ms | 1 MiB |
+| STRING (원본 JSON) | 6,104 ms | 48 GiB |
+
+핵심 결과:
+
+- **구체화된 서브컬럼의 성능이 가장 좋습니다.** 기본 모드와 DOC Materialized 모두 ~76 ms로, 원본 STRING보다 80×, JSONB보다 12× 빠릅니다.
+- **DOC Map에 샤딩을 적용하면 도움이 됩니다.** doc map을 샤딩하면 구체화되지 않은 경로의 쿼리 시간이 2.5 s에서 148 ms로 줄어듭니다.
+- **JSONB와 STRING은 메모리를 많이 사용합니다.** 최대 메모리 사용량이 32–48 GiB에 달하지만, VARIANT 모드는 1 MiB를 사용합니다.
+
+## 모범 사례 {#best-practices}
+
+### 데이터 적재 단계 {#import-phase}
+
+- **새로운 `VARIANT` 테이블은 Storage Format V3로 시작하세요.** V3는 컬럼 메타데이터를 세그먼트 푸터에서 분리합니다. 이를 사용하지 않으면 와이드 JSON 워크로드에서 파일 열기가 느려지고 메모리 오버헤드가 커집니다.
+- **핵심 경로는 초기에 Schema Template으로 고정하세요.** Schema Template이 없으면 시스템이 타입을 자동으로 추론합니다. 배치마다 같은 경로의 타입이 바뀌면(예: 정수에서 문자열로 변경) JSONB로 승격되고 해당 경로의 인덱스가 사라집니다.
+- **기본 설정으로 시작하고 증상에 따라 조정하세요.** 대부분의 워크로드에는 기본값으로 충분합니다. AI 학습, 커넥티드 차량, 사용자 태그 시스템 같은 워크로드에서 유난히 큰 Subcolumnization 규모와 많은 경로별 인덱스가 필요할 때만 시나리오에 맞게 조정하세요. 첫날부터 과도하게 설정하면(`variant_max_subcolumns_count`를 매우 크게 설정하거나 필요하지 않은 DOC 모드를 활성화하는 등) 이점이 있다는 근거 없이 복잡성만 늘어납니다.
+
+### 쿼리 단계 {#query-phase}
+
+- **`SELECT *`를 폭이 매우 넓은 `VARIANT` 컬럼의 주 쿼리 패턴으로 사용하지 마세요.** DOC 모드를 사용하지 않으면 `SELECT *` 또는 `SELECT variant_col`은 모든 서브컬럼에서 큰 JSON을 재구성해야 하므로, `SELECT v['path']`처럼 경로를 지정하는 것보다 훨씬 느립니다.
+- **쿼리가 타입에 의존할 때는 항상 하위 경로에 CAST를 적용하세요.** 타입 추론 결과가 예상과 다를 수 있습니다. `v['id']`가 실제로 STRING으로 저장되어 있는데 정수 리터럴과 비교하면 인덱스가 사용되지 않으며 결과가 잘못될 수 있습니다.
+
+### 운영 단계 {#operations-phase}
+
+- **컴팩션 부담을 살펴보세요.** 서브컬럼이 늘어나면 병합 비용이 증가합니다. Compaction Score가 계속 상승한다면 `variant_max_subcolumns_count`가 너무 높거나 데이터 적재 속도가 너무 빠르지 않은지 확인하세요.
+- **스키마 드리프트를 살펴보세요.** JSON 구조가 자주 바뀌면 핫 경로가 희소 스토리지로 밀려나 쿼리가 갑자기 느려질 수 있습니다. 중요한 경로는 Schema Template으로 고정하세요.
+- **타입 충돌을 살펴보세요.** 같은 경로에서 타입 충돌이 자주 발생한다면 JSONB 승격과 인덱스 손실을 방지하도록 해당 경로를 Schema Template으로 고정해야 한다는 신호입니다.
+
+## 빠른 검증 {#quick-verify}
+
+테이블을 생성한 후 다음의 최소한의 절차로 모든 기능이 작동하는지 확인하세요.
+
+```sql
+-- Insert sample data
+INSERT INTO event_log VALUES
+    ('2025-01-01 10:00:00', 1001, 'click', '{"page": "home", "user_id": 42, "duration_ms": 320}'),
+    ('2025-01-01 10:00:01', 1002, 'purchase', '{"item": "widget", "price": 9.99, "user_id": 42}'),
+    ('2025-01-01 10:00:02', 1003, 'click', '{"page": "search", "user_id": 99, "query": "doris variant"}');
+
+-- Verify data
+SELECT payload['user_id'], payload['page'] FROM event_log;
+
+-- Check Subcolumnization results
+SET describe_extend_variant_column = true;
+DESC event_log;
+
+-- Check per-row types
+SELECT variant_type(payload) FROM event_log;
+```
+
+## 관련 문서 {#related-reading}
+
+- [VARIANT](./VARIANT)
+- [Variant 데이터 적재](../../../../data-operate/import/complex-types/variant)
+- [Storage Format V3](../../../../table-design/storage-format)
+- [SEARCH 함수](../../../../table-design/index/inverted-index/search-function.md)
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/CHAR.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/CHAR.md
new file mode 100644
index 00000000000..b79cf92c4e5
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/CHAR.md
@@ -0,0 +1,18 @@
+---
+{
+    "title": "CHAR | 문자열 타입",
+    "language": "ko",
+    "description": "CHAR(M) 고정 길이 문자열입니다. M은 고정 길이 문자열의 바이트 길이를 나타내며, 범위는 1-255입니다.",
+    "sidebar_label": "CHAR"
+}
+---
+
+# CHAR {#char}
+
+## CHAR {#char-1}
+### 설명 {#description}
+CHAR(M)
+고정 길이 문자열입니다. M은 고정 길이 문자열의 바이트 길이를 나타내며, 범위는 1-255입니다.
+
+### 키워드 {#keywords}
+CHAR
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/STRING.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/STRING.md
new file mode 100644
index 00000000000..68d13aed74c
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/STRING.md
@@ -0,0 +1,16 @@
+---
+{
+    "title": "STRING",
+    "language": "ko",
+    "description": "가변 길이 문자열입니다. 기본적으로 10485760바이트(10 MiB)를 지원하며, 최대 2147483643바이트(2G)까지 조정할 수 있습니다."
+}
+---
+
+## STRING {#string}
+### 설명 {#description}
+기본 소프트 길이 제한이 10485760바이트(10 MiB)인 가변 길이 문자열입니다. BE에서 `string_type_length_soft_limit_bytes`를 설정하면 이 제한을 최대 2147483643바이트(약 2 GiB)까지 늘릴 수 있습니다. STRING은 값 컬럼에만 사용할 수 있으며, 키, 파티션 또는 버킷 컬럼에는 사용할 수 없습니다.
+
+참고: 가변 길이 문자열은 UTF-8 인코딩으로 저장되므로 일반적으로 영문자는 1바이트, 한자는 3바이트를 차지합니다.
+
+### 키워드 {#keywords}
+STRING
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/VARCHAR.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/VARCHAR.md
new file mode 100644
index 00000000000..5b9bc0798d7
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/sql-data-types/string-type/VARCHAR.md
@@ -0,0 +1,17 @@
+---
+{
+    "title": "VARCHAR",
+    "language": "ko",
+    "description": "VARCHAR(M) 가변 길이 문자열로, M은 문자열의 바이트 길이를 나타냅니다. M의 범위는 1-65533입니다."
+}
+---
+
+## VARCHAR {#varchar}
+### 설명 {#description}
+VARCHAR(M)
+가변 길이 문자열로, M은 문자열의 바이트 길이를 나타냅니다. M의 범위는 1-65533입니다.
+
+참고: 가변 길이 문자열은 UTF-8 인코딩으로 저장되므로, 일반적으로 영문자는 1바이트, 중국어 문자는 3바이트를 차지합니다.
+
+### 키워드 {#keywords}
+VARCHAR
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/variables.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/variables.md
new file mode 100644
index 00000000000..a0797978102
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/basic-element/variables.md
@@ -0,0 +1,211 @@
+---
+{
+    "title": "변수",
+    "language": "ko",
+    "description": "Doris에서 변수는 시스템 변수와 사용자 변수로 나뉩니다. 둘 다 대소문자를 구분하지 않습니다."
+}
+---
+
+## 설명 {#description}
+
+Doris에서 변수는 시스템 변수와 사용자 변수로 나뉩니다. 둘 다 대소문자를 구분하지 않습니다.
+
+시스템 변수는 Doris의 동작에 영향을 줍니다. 시스템 변수와 사용자 변수 모두 사용자 쿼리에서 사용할 수 있습니다.
+
+## 시스템 변수 {#system-variables}
+
+시스템 변수는 데이터베이스의 동작과 성능을 제어하기 위해 Doris에서 미리 정의한 변수 집합입니다. 주요 특징은 다음과 같습니다.
+
+- 변수 유형:
+
+    - 읽기 전용 변수: 시스템에서 설정하며 사용자가 수정할 수 없는 변수입니다. 예를 들어 `version`, `current_timestamp` 등이 있습니다.
+
+    - 수정 가능한 변수: 사용자가 실행 중에 값을 수정할 수 있는 변수입니다. 예를 들어 `exec_mem_limit`, `time_zone` 등이 있습니다.
+
+- 적용 범위:
+
+    - 전역 변수(Global): 모든 세션에 영향을 주며 `SET GLOBAL`로 설정합니다.
+
+    - 세션 변수(Session): 현재 세션에만 영향을 주며 `SET`으로 설정합니다.
+
+    - 일부 변수는 전역 범위와 세션 범위를 모두 지원합니다.
+
+- 조회 방법:
+
+    - `SHOW VARIABLES`를 사용하여 모든 시스템 변수를 조회합니다.
+
+    - `SHOW VARIABLES LIKE 'pattern'`을 사용하여 패턴과 일치하는 특정 변수를 조회합니다.
+
+    - 개별 세션 변수의 값과 효과는 [세션 변수 목록](./session-variables.md)을 참조하세요.
+
+- 지속성:
+
+    - 전역 변수의 변경 사항은 시스템을 다시 시작하면 기본값으로 재설정됩니다. 세션을 다시 시작해도 기본값으로 재설정되지는 않습니다.
+
+    - 세션 변수의 변경 사항은 세션이 종료되면 사라집니다.
+
+## 사용자 정의 변수 {#user-defined-variables}
+
+사용자 정의 변수는 세션 내에서 데이터를 임시로 저장하는 기능입니다. 주요 특징은 다음과 같습니다.
+
+- 이름 지정 규칙:
+
+    - 이름 앞에 `@`를 붙여야 합니다.
+
+    - 변수 이름에는 문자, 숫자, 밑줄을 사용할 수 있습니다.
+
+    - 대소문자를 구분하지 않습니다.
+
+- 적용 범위:
+
+    - 현재 세션 내에서만 유효합니다.
+
+    - 세션이 종료되면 자동으로 삭제됩니다.
+
+    - 서로 다른 세션에서 이름이 같은 변수는 서로 독립적입니다.
+
+- 값 할당 방법:
+
+    - `SET @var_name = value` 구문을 사용하여 값을 할당합니다.
+
+    - 표현식의 결과를 값으로 할당할 수 있습니다.
+
+- 데이터 유형:
+
+    - 숫자(정수, 부동 소수점 수)를 저장할 수 있습니다.
+
+    - 문자열을 저장할 수 있습니다.
+
+    - 날짜 및 시간 값을 저장할 수 있습니다.
+
+    - NULL 값을 저장할 수 있습니다.
+
+    - 유형은 값을 할당할 때 자동으로 결정됩니다.
+
+## 시스템 변수 정의 및 쿼리 구문 {#system-variable-definitions-and-query-statements}
+
+- SHOW VARIABLES
+
+    `SHOW VARIABLES LIKE 'variable_name'`으로 변수를 조회할 수 있습니다.
+
+    ```sql
+    SHOW VARIABLES LIKE '%time_zone%';
+    +------------------+----------------+----------------+---------+
+    | Variable_name    | Value          | Default_Value  | Changed |
+    +------------------+----------------+----------------+---------+
+    | system_time_zone | Asia/Hong_Kong | Asia/Hong_Kong | 0       |
+    | time_zone        | Asia/Hong_Kong | Asia/Hong_Kong | 0       |
+    +------------------+----------------+----------------+---------+
+    ```
+
+    또는 `SHOW VARIABLES`로 모든 변수를 조회할 수 있습니다.
+
+    ```sql
+    SHOW VARIABLES
+    +------------------------------------------------------------------+---------------------------------------+---------------------------------------+---------+
+    | Variable_name                                                    | Value                                 | Default_Value                         | Changed |
+    +------------------------------------------------------------------+---------------------------------------+---------------------------------------+---------+
+    | DML_PLAN_RETRY_TIMES                                             | 3                                     | 3                                     | 0       |
+    | adaptive_pipeline_task_serial_read_on_limit                      | 10000                                 | 10000                                 | 0       |
+    | allow_modify_materialized_view                              | false                                 | false                                 | 0       |
+    | allow_partition_column_nullable                            | true                                  | true                                  | 0       |
+    | analyze_timeout                                           | 43200                                 | 43200                                 | 0       |
+    | version                                                      | 5.7.99                                | 5.7.99                                | 0       |
+    | version_comment                                                | Doris version doris-0.0.0--de61c58223 | Doris version doris-0.0.0--de61c58223 | 0       |
+    | wait_full_block_schedule_times                                 | 2                                     | 2                                     | 0       |
+    | wait_timeout                                               | 28800                                 | 28800                                 | 0       |
+    | workload_group                                                 |                                       |                                       | 0       |
+    +------------------------------------------------------------------+---------------------------------------+---------------------------------------+---------+
+    360 rows in set (0.01 sec)
+    ```
+
+- SET
+
+    일부 변수는 전역으로 적용되거나 현재 세션에만 적용되도록 설정할 수 있습니다.
+
+    `SET`을 사용하면 현재 세션에만 적용되도록 설정합니다. 예를 들면 다음과 같습니다.
+
+    ```sql
+    SET exec_mem_limit = 137438953472;
+    SHOW VARIABLES LIKE '%exec_mem_limit%';
+    +----------------+--------------+---------------+---------+
+    | Variable_name  | Value        | Default_Value | Changed |
+    +----------------+--------------+---------------+---------+
+    | exec_mem_limit | 137438953472 | 2147483648    | 1       |
+    +----------------+--------------+---------------+---------+
+    1 row in set (0.01 sec)
+    SET forward_to_master = true;
+    SHOW VARIABLES LIKE '%forward_to_master%';
+    +-------------------+-------+---------------+---------+
+    | Variable_name     | Value | Default_Value | Changed |
+    +-------------------+-------+---------------+---------+
+    | forward_to_master | true  | true          | 0       |
+    +-------------------+-------+---------------+---------+
+    1 row in set (0.00 sec)
+    SET time_zone = "Asia/Shanghai";
+    SHOW VARIABLES LIKE '%time_zone%';
+    +------------------+----------------+----------------+---------+
+    | Variable_name    | Value          | Default_Value  | Changed |
+    +------------------+----------------+----------------+---------+
+    | time_zone        | Asia/Shanghai  | Asia/Hong_Kong | 1       |
+    | system_time_zone | Asia/Hong_Kong | Asia/Hong_Kong | 0       |
+    +------------------+----------------+----------------+---------+
+    2 rows in set (0.00 sec)
+    ```
+
+    전역으로 설정
+
+    ```sql
+    SET GLOBAL exec_mem_limit = 137438953472;
+    SHOW VARIABLES LIKE '%exec_mem_limit%';
+    +----------------+--------------+---------------+---------+
+    | Variable_name  | Value        | Default_Value | Changed |
+    +----------------+--------------+---------------+---------+
+    | exec_mem_limit | 137438953472 | 2147483648    | 1       |
+    +----------------+--------------+---------------+---------+
+    1 row in set (0.01 sec)
+    ```
+
+- UNSET
+
+    구문:
+
+    ```sql
+    UNSET (GLOBAL | SESSION | LOCAL)? VARIABLE (ALL | identifier)
+    unset global variable exec_mem_limit;
+    SHOW VARIABLES LIKE '%exec_mem_limit%';
+    +----------------+------------+---------------+---------+
+    | Variable_name  | Value      | Default_Value | Changed |
+    +----------------+------------+---------------+---------+
+    | exec_mem_limit | 2147483648 | 2147483648    | 0       |
+    +----------------+------------+---------------+---------+
+    1 row in set (0.00 sec)
+    ```
+
+## 사용자 변수 정의 및 쿼리 구문 {#user-variable-definition-and-query-statements}
+
+사용자 정의 변수는 다음 구문으로 정의할 수 있습니다.
+
+```sql
+SET @var_name = constant_value|constant_expr;
+```
+
+설정 예시:
+
+```sql
+SET @v1 = "A";
+SET @v2 = 32+33;
+SET @v3 = str_to_date("2024-12-29 10:11:12", '%Y-%m-%d %H:%i:%s');
+```
+
+쿼리에서 사용할 수 있습니다.
+
+```sql
+SELECT @v1, @v2, @v3;
++------+------+--------------------+
+| @v1  | @v2  | @v3                 |
++------+------+--------------------+
+| A    |   65 | 2024-12-29 10:11:12 |
++------+------+--------------------+
+1 row in set (0.01 sec)
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/ai-agg.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/ai-agg.md
new file mode 100644
index 00000000000..10fdcf175db
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/ai-agg.md
@@ -0,0 +1,136 @@
+---
+{
+    "title": "AI_AGG",
+    "language": "ko",
+    "description": "사용자가 제공한 지침에 따라 대규모 언어 모델을 사용하여 특정 컬럼을 집계합니다."
+}
+---
+
+## 설명 {#description}
+
+사용자가 제공한 지침에 따라 대규모 언어 모델을 사용하여 특정 컬럼을 집계합니다.
+
+## 구문 {#syntax}
+
+```sql
+AI_AGG([<resource_name>], <expr>, <instruction>)
+```
+
+<a id="parameter-description"></a>
+
+## 매개변수 {#parameters}
+
+| 매개변수         | 설명                                             |
+| ----------------- | ------------------------------------------------------- |
+| `<resource_name>` | 지정할 리소스 이름입니다. 선택 사항입니다.                  |
+| `<expr>`          | 집계할 텍스트 컬럼입니다. 개별 텍스트의 문자 수는 128K 미만이어야 합니다.|
+| `<instruction>`   | 실행할 지침입니다. 리터럴만 허용됩니다.      |
+
+## 반환값 {#return-value}
+
+4.1.5 버전부터 AI_AGG는 JSON 배열이 포함된 텍스트를 비롯해 모델이 생성한 전체 텍스트를 하나의 결과로 반환합니다. 해당 배열을 여러 집계 결과로 나누지 않습니다. OpenAI Responses 형식에서는 reasoning 및 tool 항목과 같이 텍스트가 아닌 출력을 건너뛰고, message 항목의 `output_text`를 이어 붙입니다. 응답에 상태가 포함되어 있으면 해당 상태는 `completed`여야 합니다. 응답이 불완전하거나 응답에 텍스트가 없으면 오류가 발생합니다.
+
+집계 결과가 담긴 문자열을 반환합니다.
+
+모든 입력값이 NULL이면 NULL을 반환합니다.
+
+결과는 언어 모델이 생성하므로 출력은 고정되어 있지 않습니다.
+
+## 예제 {#example}
+
+다음 테이블은 고객 지원 티켓을 가정한 예시입니다:
+```sql
+CREATE TABLE support_tickets (
+    ticket_id      BIGINT,
+    customer_name  VARCHAR(100),
+    subject        VARCHAR(200),
+    details        TEXT
+)
+DUPLICATE KEY(ticket_id)
+DISTRIBUTED BY HASH(ticket_id) BUCKETS 5
+PROPERTIES (
+    "replication_num" = "1"
+);
+
+INSERT INTO support_tickets VALUES
+(1, 'Alice', 'Login Failure', 'Cannot log in after password reset. Tried clearing cache and different browsers.'),
+(2, 'Bob', 'Login Failure', 'Same problem as Alice. Also seeing 502 errors on the SSO page.'),
+(3, 'Carol', 'Payment Declined', 'Credit card charged twice but order still shows pending.'),
+(4, 'Dave', 'Slow Dashboard', 'Dashboard takes >30 seconds to load since the last release.'),
+(5, 'Eve', 'Login Failure', 'Getting redirected back to login after entering 2FA code.');
+```
+
+`AI_AGG`를 사용하여 문제 제목별로 고객 문제를 요약할 수 있습니다:
+```sql
+SELECT
+    subject,
+    AI_AGG(
+        'ai_resource_name',
+        details,
+        'Summarize every ticket detail into one short paragraph of 40 words or less.'
+    ) AS ai_summary
+FROM support_tickets
+GROUP BY subject;
+```
+
+```text
++------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| subject          | ai_summary                                                                                                                                                                                                |
++------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Slow Dashboard   | The dashboard loading time has significantly increased to over 30 seconds following the latest release, indicating a potential issue with the recent update.                                              |
+| Login Failure    | User experiences login issues, including redirection post-2FA, inability to log in after password reset despite using different browsers and clearing cache, and encountering 502 errors on the SSO page. |
+| Payment Declined | The customer's credit card was charged twice, but the order status remains pending, indicating a potential issue with the transaction processing or system update.                                        |
++------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+사례 2:
+
+다음 테이블은 전자 상거래 플랫폼의 사용자 리뷰 테이블을 가정한 예시입니다.
+```sql
+CREATE TABLE product_reviews (
+    review_id   BIGINT,
+    product_id  BIGINT,
+    rating      TINYINT,
+    comment     STRING
+)
+DUPLICATE KEY(review_id)
+DISTRIBUTED BY HASH(product_id) BUCKETS 10
+PROPERTIES (
+    "replication_num" = "1"
+);
+
+INSERT INTO product_reviews VALUES
+(1, 1001, 5, '鞋子尺码刚好,穿着舒服,颜色也好看,物流很快!'),
+(2, 1001, 4, '质量不错,就是鞋底有点硬,需要磨合几天。'),
+(3, 1001, 3, '外观和图片一样,但收到时有轻微胶味。'),
+(4, 1002, 5, '杯子小巧,出汁快,清洗也方便,上班带着刚好。'),
+(5, 1002, 3, '声音有点大,不过能接受,充满电只能榨 5 杯。'),
+(6, 1002, 2, '用了两周就充不进电,售后换货流程太慢。'),
+(7, 1003, 5, '面料透气不闷热,袖口设计很贴心,UPF50+ 确实晒不黑。'),
+(8, 1003, 4, '颜色好看,但拉链有点卡顿,需要用力。'),
+(9, 1004, 5, '降噪给力,地铁里也能安静听歌,续航一周充一次。');
+```
+
+AI_AGG를 사용하여 요약하고 평가합니다:
+```sql
+SET default_ai_resource = 'ai_resource_name';
+SELECT
+    product_id,
+    AI_AGG(
+        comment,
+        '请把多条用户评价总结成一句话,突出买家最关心的优点和缺点,控制在50字以内。'
+    ) AS 评价摘要
+FROM product_reviews
+GROUP BY product_id;
+```
+
+```text
++------------+--------------------------------------------------------------------------------------------------------------+
+| product_id | 评价摘要                                                                                                     |
++------------+--------------------------------------------------------------------------------------------------------------+
+|       1003 | 该产品面料透气、防晒效果好且颜色美观,但拉链使用不顺畅。                                                     |
+|       1004 | 用户评价该产品降噪效果好,续航能力强,一周充一次电。                                                         |
+|       1001 | 买家普遍认为鞋子穿着舒适、外观好看且物流快,但鞋底偏硬且有轻微胶味。                                         |
+|       1002 | 买家认为该榨汁杯小巧便携、出汁快且易清洗,但电池续航短且售后换货流程慢。                                     |
++------------+--------------------------------------------------------------------------------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/any-value.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/any-value.md
new file mode 100644
index 00000000000..bbe1280939e
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/any-value.md
@@ -0,0 +1,113 @@
+---
+{
+    "title": "ANY_VALUE",
+    "language": "ko",
+    "description": "그룹 내 표현식 또는 컬럼에서 임의의 값을 반환합니다. NULL이 아닌 값이 있으면 그중 임의의 값을 반환하고, 그렇지 않으면 NULL을 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+그룹 내 표현식 또는 컬럼에서 임의의 값을 반환합니다. NULL이 아닌 값이 있으면 그중 임의의 값을 반환하고, 그렇지 않으면 NULL을 반환합니다.
+
+## 별칭 {#alias}
+
+- ANY
+
+## 구문 {#syntax}
+
+```sql
+ANY_VALUE(<expr>)
+ANY(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 집계할 컬럼 또는 표현식입니다. 지원되는 타입은 String, Date, DateTime, Timestamptz, IPv4, IPv6, Bool, TinyInt, SmallInt, Integer, BigInt, LargeInt, Float, Double, Decimal, Array, Map, Struct, AggState, Bitmap, HLL, QuantileState입니다. |
+
+## 반환값 {#return-value}
+
+NULL이 아닌 값이 있으면 그중 임의의 값을 반환하고, 그렇지 않으면 NULL을 반환합니다.
+반환 타입은 입력 expr의 타입과 동일합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table t1(
+        k1 int,
+        k_string varchar(100),
+        k_decimal decimal(10, 2)
+) distributed by hash (k1) buckets 1
+properties ("replication_num"="1");
+insert into t1 values 
+    (1, 'apple', 10.01),
+    (1, 'banana', 20.02),
+    (2, 'orange', 30.03),
+    (2, null, null),
+    (3, null, null);
+```
+
+```sql
+select k1, any_value(k_string) from t1 group by k1;
+```
+
+String 타입: 각 그룹에서 NULL이 아닌 임의의 값을 반환합니다.
+
+```text
++------+---------------------+
+| k1   | any_value(k_string) |
++------+---------------------+
+|    1 | apple               |
+|    2 | orange              |
+|    3 | NULL                |
++------+---------------------+
+```
+
+```sql
+select k1, any_value(k_decimal) from t1 group by k1;
+```
+
+Decimal 타입: NULL이 아닌 임의의 고정밀도 십진수 값을 반환합니다.
+
+```text
++------+----------------------+
+| k1   | any_value(k_decimal) |
++------+----------------------+
+|    1 |                10.01 |
+|    2 |                30.03 |
+|    3 |                 NULL |
++------+----------------------+
+```
+
+```sql
+select any_value(k_string) from t1 where k1 = 3;
+```
+
+그룹 내 모든 값이 NULL이면 NULL을 반환합니다.
+
+```text
++---------------------+
+| any_value(k_string) |
++---------------------+
+| NULL                |
++---------------------+
+```
+
+```sql
+select k1, any(k_string) from t1 group by k1;
+```
+
+별칭 ANY를 사용하면 ANY_VALUE와 동일하게 동작합니다.
+
+```text
++------+---------------+
+| k1   | any(k_string) |
++------+---------------+
+|    1 | apple         |
+|    2 | orange        |
+|    3 | NULL          |
++------+---------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/approx-count-distinct.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/approx-count-distinct.md
new file mode 100644
index 00000000000..a44c7681847
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/approx-count-distinct.md
@@ -0,0 +1,136 @@
+---
+{
+    "title": "APPROX_COUNT_DISTINCT",
+    "language": "ko",
+    "description": "NULL이 아닌 요소의 중복을 제외한 개수를 반환합니다. 이 함수는 HyperLogLog 알고리즘을 기반으로 구현됩니다."
+}
+---
+
+## 설명 {#description}
+
+NULL이 아닌 요소의 중복을 제외한 개수를 반환합니다.
+이 함수는 HyperLogLog 알고리즘을 기반으로 구현되었으며, 고정된 크기의 메모리를 사용하여 컬럼의 고유 값 개수를 추정합니다. 이 알고리즘은 꼬리 부분이 null 분포를 따른다는 가정을 바탕으로 하며, 정확도는 데이터 분포에 따라 달라집니다. Doris에서 사용하는 고정 버킷 크기를 기준으로 이 알고리즘의 상대 표준 오차는 0.8125%입니다.
+더 자세하고 구체적인 분석은 [관련 논문](https://algo.inria.fr/flajolet/Publications/FlFuGaMe07.pdf)을 참조하세요.
+
+## 구문 {#syntax}
+
+```sql
+APPROX_COUNT_DISTINCT(<expr>)
+NDV(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 값을 구할 표현식입니다. 지원되는 타입은 String, Date, DateTime,Timestamptz, IPv4, IPv6, TinyInt, Bool, SmallInt, Integer, BigInt, LargeInt, Float, Double, Decimal입니다. |
+
+## 반환 값 {#return-value}
+
+BIGINT 타입의 값을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table t1(
+        k1 int,
+        k_string varchar(100),
+        k_tinyint tinyint
+) distributed by hash (k1) buckets 1
+properties ("replication_num"="1");
+insert into t1 values 
+    (1, 'apple', 10),
+    (1, 'banana', 20),
+    (1, 'apple', 10),
+    (2, 'orange', 30),
+    (2, 'orange', 40),
+    (2, 'grape', 50),
+    (3, null, null);
+```
+
+```sql
+select approx_count_distinct(k_string) from t1;
+```
+
+String 타입: 전체 k_string 값의 중복을 제외한 개수를 근사적으로 계산합니다. NULL 값은 계산에 포함되지 않습니다.
+
+```text
++---------------------------------+
+| approx_count_distinct(k_string) |
++---------------------------------+
+|                               4 |
++---------------------------------+
+```
+
+```sql
+select approx_count_distinct(k_tinyint) from t1;
+```
+
+TinyInt 타입: 전체 k_tinyint 값의 중복을 제외한 개수를 근사적으로 계산합니다.
+
+```text
++----------------------------------+
+| approx_count_distinct(k_tinyint) |
++----------------------------------+
+|                                5 |
++----------------------------------+
+```
+
+```sql
+select approx_count_distinct(k1) from t1;
+```
+
+Integer 타입: 전체 k1 값의 중복을 제외한 개수를 근사적으로 계산합니다.
+
+```text
++---------------------------+
+| approx_count_distinct(k1) |
++---------------------------+
+|                         3 |
++---------------------------+
+```
+
+```sql
+select k1, approx_count_distinct(k_string) from t1 group by k1;
+```
+
+k1을 기준으로 그룹화하고 각 그룹에서 k_string 값의 중복을 제외한 개수를 근사적으로 계산합니다. 그룹 내 모든 레코드가 NULL이면 0을 반환합니다.
+
+```text
++------+---------------------------------+
+| k1   | approx_count_distinct(k_string) |
++------+---------------------------------+
+|    1 |                               2 |
+|    2 |                               2 |
+|    3 |                               0 |
++------+---------------------------------+
+```
+
+```sql
+select ndv(k_string) from t1;
+```
+
+별칭인 NDV를 사용해도 APPROX_COUNT_DISTINCT와 동일하게 동작합니다.
+
+```text
++---------------+
+| ndv(k_string) |
++---------------+
+|             4 |
++---------------+
+```
+
+```sql
+select approx_count_distinct(k_string) from t1 where k1 = 999;
+```
+
+쿼리 결과가 비어 있으면 0을 반환합니다.
+
+```text
++---------------------------------+
+| approx_count_distinct(k_string) |
++---------------------------------+
+|                               0 |
++---------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/array-agg.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/array-agg.md
new file mode 100644
index 00000000000..31cb11b9c97
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/array-agg.md
@@ -0,0 +1,69 @@
+---
+{
+    "title": "ARRAY_AGG",
+    "language": "ko",
+    "description": "열의 값(null 값 포함)을 하나의 배열로 연결합니다. 행을 열로 피벗하는 데 사용할 수 있습니다."
+}
+---
+
+## 설명 {#description}
+
+열의 값(null 값 포함)을 하나의 배열로 연결합니다. 행을 열로 피벗하는 데 사용할 수 있습니다.
+
+## 구문 {#syntax}
+
+```sql
+ARRAY_AGG(<col>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<col>` | 배열에 넣을 값을 결정하는 표현식입니다. 지원하는 타입: Bool, TinyInt, SmallInt, Integer, BigInt, LargeInt, Float, Double, Decimal, Date, Datetime, Timestamptz, IPV4, IPV6, String, Array, Map, Struct. |
+
+## 반환 값 {#return-value}
+
+ARRAY 타입의 값을 반환합니다. 특수한 경우는 다음과 같습니다:
+
+- 배열 요소의 순서는 보장되지 않습니다.
+- 변환으로 생성된 배열을 반환합니다. 배열 요소의 타입은 col의 타입과 일치합니다.
+
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE test_doris_array_agg (
+	c1 INT,
+	c2 INT
+) DISTRIBUTED BY HASH(c1) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO test_doris_array_agg VALUES (1, 10), (1, 20), (1, 30), (2, 100), (2, 200), (3, NULL);
+```
+
+```sql
+select c1, array_agg(c2) from test_doris_array_agg group by c1;
+```
+
+```text
++------+---------------+
+| c1   | array_agg(c2) |
++------+---------------+
+|    1 | [10, 20, 30]  |
+|    2 | [100, 200]    |
+|    3 | [null]        |
++------+---------------+
+```
+
+```sql
+select array_agg(c2) from test_doris_array_agg where c1 is null;
+```
+
+```text
++---------------+
+| array_agg(c2) |
++---------------+
+| []            |
++---------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg-map.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg-map.md
new file mode 100644
index 00000000000..1c8b2fcfe5a
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg-map.md
@@ -0,0 +1,111 @@
+---
+{
+    "title": "AVG_MAP",
+    "language": "ko",
+    "description": "AVG_MAP 함수는 MAP 값을 키별로 집계하고 각 키의 평균값을 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+AVG_MAP 함수는 MAP 값을 키별로 집계하고 각 키에서 NULL이 아닌 값의 평균을 담은 MAP을 반환합니다.
+
+## 사용 시 참고 사항 {#usage-notes}
+
+반환되는 MAP의 항목 순서는 보장되지 않습니다. 일관된 출력 순서가 필요한 경우 `map_keys`, `map_values`, `array_sort`, `array_sortby`를 사용하세요. NULL 키는 일반 키로 집계되며, 모든 NULL 키는 결과의 동일한 항목에 속합니다.
+
+## 구문 {#syntax}
+
+```sql
+AVG_MAP(<map_expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| --- | --- |
+| `<map_expr>` | MAP 표현식입니다. MAP의 값 타입은 숫자 타입이어야 합니다. |
+
+## 반환 값 {#return-value}
+
+`<map_expr>`와 키 타입이 같은 MAP을 반환합니다. Decimal 이외의 숫자 값 타입에 대해서는 반환되는 값 타입이 DOUBLE입니다. Decimal 값 타입에 대해서는 지원되는 최대 정밀도와 AVG에 맞게 조정된 스케일을 갖는 Decimal 타입이 반환됩니다.
+
+그룹에 유효한 입력 행이 없으면 빈 MAP을 반환합니다. 키가 존재하지만 해당 키의 모든 값이 NULL이면 해당 키의 값은 NULL입니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE map_agg_example (
+    id INT,
+    m MAP<INT, INT>,
+    md MAP<STRING, DECIMAL(10, 2)>
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO map_agg_example VALUES
+    (1, MAP(1, 10, 2, 20), MAP('a', 1.20, 'b', 2.30)),
+    (1, MAP(2, 5, 3, 30), MAP('b', 3.70, 'c', 4.00)),
+    (2, MAP(1, 7, 4, NULL), MAP('a', NULL, 'c', 5.50)),
+    (2, CAST(MAP() AS MAP<INT, INT>), CAST(MAP() AS MAP<STRING, DECIMAL(10, 2)>));
+```
+
+```text
+Query OK
+```
+
+```sql
+SELECT id,
+       array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT id, AVG_MAP(m) AS result
+    FROM map_agg_example
+    GROUP BY id
+) t
+ORDER BY id;
+```
+
+```text
++------+-----------+----------------+
+| id   | keys      | values         |
++------+-----------+----------------+
+|    1 | [1, 2, 3] | [10, 12.5, 30] |
+|    2 | [1, 4]    | [7, null]      |
++------+-----------+----------------+
+```
+
+```sql
+SELECT array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT AVG_MAP(md) AS result
+    FROM map_agg_example
+) t;
+```
+
+```text
++-----------------+------------------------+
+| keys            | values                 |
++-----------------+------------------------+
+| ["a", "b", "c"] | [1.2000, 3.0000, 4.7500] |
++-----------------+------------------------+
+```
+
+```sql
+SELECT array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT AVG_MAP(m) AS result
+    FROM map_agg_example
+    WHERE id = 100
+) t;
+```
+
+```text
++------+--------+
+| keys | values |
++------+--------+
+| []   | []     |
++------+--------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg-weighted.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg-weighted.md
new file mode 100644
index 00000000000..9a60bb6daac
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg-weighted.md
@@ -0,0 +1,108 @@
+---
+{
+    "title": "AVG_WEIGHTED",
+    "language": "ko",
+    "description": "가중 산술 평균을 계산합니다. 즉, 결과는 각 값과 해당 가중치의 곱을 모두 더한 값이며,"
+}
+---
+
+## 설명 {#description}
+
+가중 산술 평균을 계산합니다. 즉, 각 값과 해당 가중치의 곱을 모두 더한 값을 가중치의 총합으로 나눈 결과입니다. 가중치의 총합이 0이면 NaN을 반환합니다. 계산은 항상 Double 타입을 사용하여 수행합니다.
+
+## 구문 {#syntax}
+
+```sql
+AVG_WEIGHTED(<x>, <weight>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<x>` | 평균을 계산할 숫자 표현식으로, 컬럼 이름, 상수 또는 복잡한 숫자 표현식을 사용할 수 있습니다. 지원되는 타입은 Double입니다. |
+| `<weight>` | 숫자 표현식으로, 일반적으로 컬럼 이름, 상수 또는 다른 숫자 계산의 결과를 사용합니다. 지원되는 타입은 Double입니다. |
+
+## 반환 값 {#return-value}
+
+각 값과 해당 가중치의 곱을 모두 더한 후 가중치의 총합으로 나눈 값을 반환합니다. 가중치의 총합이 0이면 NaN을 반환합니다.
+반환 타입은 항상 Double입니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table t1(
+        k1 int,
+        k2 int,
+        k3 decimal(10, 2),
+        k4 double,
+        category varchar(50)
+) distributed by hash (k1) buckets 1
+properties ("replication_num"="1");
+insert into t1 values 
+    (10, 100, 5.5, 1.0, 'A'),
+    (20, 200, 10.0, 2.0, 'A'),
+    (30, 300, 15.5, 3.0, 'B'),
+    (40, 400, 20.0, 4.0, 'B'),
+    (50, 0, 25.0, 0.0, 'C'),
+    (60, 600, 30.0, 5.0, 'C');
+```
+
+```sql
+select avg_weighted(k2, k1) from t1;
+```
+
+전체 레코드의 가중 평균을 계산합니다: (100*10 + 200*20 + 300*30 + 400*40 + 0*50 + 600*60) / (10+20+30+40+50+60) ≈ 314.2857
+
+```text
++----------------------+
+| avg_weighted(k2, k1) |
++----------------------+
+|    314.2857142857143 |
++----------------------+
+```
+
+```sql
+select category, avg_weighted(k2, k1) from t1 group by category;
+```
+
+카테고리별로 그룹화하여 각 그룹의 가중 평균을 계산합니다.
+
+```text
++----------+----------------------+
+| category | avg_weighted(k2, k1) |
++----------+----------------------+
+| A        |   166.66666666666666 |
+| B        |   357.14285714285717 |
+| C        |   327.27272727272725 |
++----------+----------------------+
+```
+
+```sql
+select avg_weighted(k2, 0) from t1;
+```
+
+모든 가중치가 0이면 NaN을 반환합니다.
+
+```text
++---------------------+
+| avg_weighted(k2, 0) |
++---------------------+
+|                 NaN |
++---------------------+
+```
+
+```sql
+select avg_weighted(k2, k1) from t1 where k1 > 100;
+```
+
+쿼리 결과가 비어 있으면 NULL을 반환합니다.
+
+```text
++----------------------+
+| avg_weighted(k2, k1) |
++----------------------+
+|                 NULL |
++----------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg.md
new file mode 100644
index 00000000000..b7e0b0209a1
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/avg.md
@@ -0,0 +1,174 @@
+---
+{
+    "title": "AVG",
+    "language": "ko",
+    "description": "지정한 열 또는 표현식에서 NULL이 아닌 모든 값의 평균을 계산합니다."
+}
+---
+
+## 설명 {#description}
+
+지정한 열 또는 표현식에서 NULL이 아닌 모든 값의 평균을 계산합니다.
+
+## 구문 {#syntax}
+
+```sql
+AVG([DISTINCT] <expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 표현식 또는 열이며, 일반적으로 숫자형 열이나 숫자 값으로 변환할 수 있는 표현식입니다. 지원되는 타입은 TinyInt, SmallInt, Integer, BigInt, LargeInt, Double, Decimal입니다. |
+| `[DISTINCT]` | expr에서 중복 값을 제거한 후 평균을 계산하도록 지정하는 선택적 키워드입니다. |
+
+## 반환값 {#return-value}
+
+선택한 열 또는 표현식의 평균값을 반환합니다. 그룹의 모든 레코드가 NULL이면 함수는 NULL을 반환합니다.
+입력이 decimal 타입이면 반환값도 decimal 타입이며, 그 외 숫자 타입은 double 타입으로 반환됩니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table t1(
+        k_tinyint tinyint,
+        k_smallint smallint,
+        k_int int,
+        k_bigint bigint,
+        k_largeint largeint,
+        k_double double,
+        k_decimal decimalv3(10, 5),
+        k_null_int int
+) distributed by hash (k_int) buckets 1
+properties ("replication_num"="1");
+insert into t1 values 
+    (1, 10, 100, 1000, 10000, 1.1, 222.222, null),
+    (2, 20, 200, 2000, 20000, 2.2, 444.444, null),
+    (3, 30, 300, 3000, 30000, 3.3, null, null);
+```
+
+```sql
+select avg(k_tinyint) from t1;
+```
+
+TinyInt 타입의 평균을 계산합니다. [1,2,3]의 평균은 2입니다.
+
+```text
++----------------+
+| avg(k_tinyint) |
++----------------+
+|              2 |
++----------------+
+```
+
+```sql
+select avg(k_smallint) from t1;
+```
+
+SmallInt 타입의 평균을 계산합니다. [10,20,30]의 평균은 20입니다.
+
+```text
++-----------------+
+| avg(k_smallint) |
++-----------------+
+|              20 |
++-----------------+
+```
+
+```sql
+select avg(k_int) from t1;
+```
+
+Integer 타입의 평균을 계산합니다. [100,200,300]의 평균은 200입니다.
+
+```text
++------------+
+| avg(k_int) |
++------------+
+|        200 |
++------------+
+```
+
+```sql
+select avg(k_bigint) from t1;
+```
+
+BigInt 타입의 평균을 계산합니다. [1000,2000,3000]의 평균은 2000입니다.
+
+```text
++---------------+
+| avg(k_bigint) |
++---------------+
+|          2000 |
++---------------+
+```
+
+```sql
+select avg(k_largeint) from t1;
+```
+
+LargeInt 타입의 평균을 계산합니다. [10000,20000,30000]의 평균은 20000입니다.
+
+```text
++-----------------+
+| avg(k_largeint) |
++-----------------+
+|           20000 |
++-----------------+
+```
+
+```sql
+select avg(k_double) from t1;
+```
+
+Double 타입의 평균을 계산합니다. [1.1,2.2,3.3]의 평균은 약 2.2입니다.
+
+```text
+| avg(k_double)      |
++--------------------+
+| 2.1999999999999997 |
+```
+
+```sql
+select avg(k_decimal) from t1;
+```
+
+Decimal 타입의 평균을 계산합니다. [222.222,444.444,null]의 평균은 333.333입니다.
+
+```text
++----------------+
+| avg(k_decimal) |
++----------------+
+|      333.33300 |
++----------------+
+```
+
+```sql
+select avg(k_null_int) from t1;
+```
+
+입력 데이터가 모두 NULL이면 NULL을 반환합니다.
+
+```text
++-----------------+
+| avg(k_null_int) |
++-----------------+
+|            NULL |
++-----------------+
+```
+
+```sql
+select avg(distinct k_bigint) from t1;
+```
+
+DISTINCT 키워드를 사용하여 중복 값을 제거한 후 평균을 계산합니다. [1000,2000,3000]에서 중복 값을 제거한 후의 평균은 2000입니다.
+
+```text
++-----------------------+
+| avg(distinct k_bigint) |
++-----------------------+
+|                  2000 |
++-----------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-agg.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-agg.md
new file mode 100644
index 00000000000..0ec4e6ce11f
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-agg.md
@@ -0,0 +1,100 @@
+---
+{
+    "title": "BITMAP_AGG",
+    "language": "ko",
+    "description": "입력 표현식의 NULL이 아닌 값을 Bitmap으로 집계합니다. 값이 0보다 작거나 18446744073709551615보다 크면,"
+}
+---
+
+## 설명 {#description}
+
+입력 표현식의 NULL이 아닌 값을 Bitmap으로 집계합니다.
+값이 0보다 작거나 18446744073709551615보다 크면 해당 값은 무시되며 Bitmap에 병합되지 않습니다.
+
+## 구문 {#syntax}
+
+```sql
+BITMAP_AGG(<expr>)
+```
+
+## 인수 {#arguments}
+
+| 인수 | 설명 |
+| -- | -- |
+| `<expr>` | 집계할 열 또는 표현식입니다. 지원되는 타입: TinyInt, SmallInt, Integer, BigInt. |
+
+## 반환 값 {#return-value}
+
+Bitmap 타입의 값을 반환합니다. 그룹에 유효한 데이터가 없으면 빈 Bitmap을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE test_bitmap_agg (
+    id INT,
+    k0 INT,
+    k1 INT,
+    k2 INT,
+    k3 INT,
+    k4 BIGINT,
+    k5 BIGINT
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO test_bitmap_agg VALUES
+    (1, 10, 110, 11, 300, 10000000000, 0),
+    (2, 20, 120, 21, 400, 20000000000, 200000000000000),
+    (3, 30, 130, 31, 350, 30000000000, 300000000000000),
+    (4, 40, 140, 41, 500, 40000000000, 18446744073709551616),
+    (5, 50, 150, 51, 250, 50000000000, 18446744073709551615),
+    (6, 60, 160, 61, 600, 60000000000, -1),
+    (7, 60, 160, 120, 600, 60000000000, NULL);
+```
+
+```sql
+select bitmap_to_string(bitmap_agg(k0)) from test_bitmap_agg;
+```
+
+```text
++----------------------------------+
+| bitmap_to_string(bitmap_agg(k0)) |
++----------------------------------+
+| 10,20,30,40,50,60                |
++----------------------------------+
+```
+
+```sql
+select bitmap_to_string(bitmap_agg(k5)) from test_bitmap_agg;
+```
+
+```text
++--------------------------------------------------------+
+| bitmap_to_string(bitmap_agg(k5))                       |
++--------------------------------------------------------+
+| 0,200000000000000,300000000000000,18446744073709551615 |
++--------------------------------------------------------+
+```
+
+```sql
+select bitmap_to_string(bitmap_agg(k5)) from test_bitmap_agg where k5 is null;
+```
+
+```text
++----------------------------------+
+| bitmap_to_string(bitmap_agg(k5)) |
++----------------------------------+
+|                                  |
++----------------------------------+
+```
+
+```sql
+select bitmap_to_string(bitmap_agg(k5)) from test_bitmap_agg;
+```
+
+```text
++--------------------------------------------------------+
+| bitmap_to_string(bitmap_agg(cast(k5 as BIGINT)))       |
++--------------------------------------------------------+
+| 0,200000000000000,300000000000000,18446744073709551615 |
++--------------------------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-intersect.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-intersect.md
new file mode 100644
index 00000000000..ee453bf7675
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-intersect.md
@@ -0,0 +1,76 @@
+---
+{
+    "title": "BITMAP_INTERSECT",
+    "language": "ko",
+    "description": "그룹별 Bitmap의 교집합을 계산하는 데 사용합니다. 일반적인 사용 사례는 사용자 유지율 계산입니다."
+}
+---
+
+## 설명 {#description}
+
+그룹별 Bitmap의 교집합을 계산하는 데 사용합니다. 일반적인 사용 사례는 사용자 유지율 계산입니다.
+
+## 구문 {#syntax}
+
+```sql
+BITMAP_INTERSECT(BITMAP <value>)
+```
+
+## 인수 {#arguments}
+
+| 인수 | 설명 |
+| -- | -- |
+| `<value>` | Bitmap을 지원하는 데이터 타입 |
+
+## 반환 값 {#return-value}
+
+Bitmap 타입의 값을 반환합니다. 그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE user_tags (
+	tag VARCHAR(20),
+	date DATETIME,
+	user_id BITMAP bitmap_union
+) AGGREGATE KEY(tag, date) DISTRIBUTED BY HASH(tag) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO user_tags VALUES
+	('A', '2020-05-18', to_bitmap(1)),
+	('A', '2020-05-18', to_bitmap(2)),
+	('A', '2020-05-19', to_bitmap(2)),
+	('A', '2020-05-19', to_bitmap(3)),
+	('B', '2020-05-18', to_bitmap(4)),
+	('B', '2020-05-19', to_bitmap(4)),
+	('B', '2020-05-19', to_bitmap(5));
+```
+
+```sql
+select tag, bitmap_to_string(bitmap_intersect(user_id)) from (
+	select tag, date, bitmap_union(user_id) user_id from user_tags where date in ('2020-05-18', '2020-05-19') group by tag, date
+) a group by tag;
+```
+
+태그별로 어제 대비 오늘의 사용자 유지율을 쿼리합니다.
+
+```text
++------+---------------------------------------------+
+| tag  | bitmap_to_string(bitmap_intersect(user_id)) |
++------+---------------------------------------------+
+| A    | 2                                           |
+| B    | 4                                           |
++------+---------------------------------------------+
+```
+
+```sql
+select bitmap_to_string(bitmap_intersect(user_id)) from user_tags where tag is null;
+```
+
+```text
++---------------------------------------------+
+| bitmap_to_string(bitmap_intersect(user_id)) |
++---------------------------------------------+
+|                                             |
++---------------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union-count.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union-count.md
new file mode 100644
index 00000000000..125ee41afd0
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union-count.md
@@ -0,0 +1,70 @@
+---
+{
+    "title": "BITMAP_UNION_COUNT",
+    "language": "ko",
+    "description": "입력 Bitmap의 합집합을 계산하고 해당 집합의 원소 수를 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+입력 Bitmap의 합집합을 계산하고 해당 집합의 원소 수를 반환합니다.
+
+## 구문 {#syntax}
+
+```sql
+BITMAP_UNION_COUNT(<expr>)
+```
+
+## 인수 {#arguments}
+
+| 인수 | 설명 |
+| -- | -- |
+| `<expr>` | Bitmap을 지원하는 데이터 타입 |
+
+## 반환 값 {#return-value}
+
+Bitmap 합집합의 크기, 즉 중복을 제외한 원소의 개수를 반환합니다. 그룹에 유효한 데이터가 없으면 0을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE pv_bitmap (
+    dt INT,
+    page INT,
+    user_id BITMAP
+) DISTRIBUTED BY HASH(dt) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO pv_bitmap VALUES
+    (1, 100, to_bitmap(100)),
+    (1, 100, to_bitmap(200)),
+    (1, 100, to_bitmap(300)),
+    (2, 200, to_bitmap(300));
+```
+
+```sql
+select bitmap_union_count(user_id) from pv_bitmap;
+```
+
+중복을 제외한 user_id 값의 개수를 계산합니다.
+
+```text
++-----------------------------+
+| bitmap_union_count(user_id) |
++-----------------------------+
+|                           3 |
++-----------------------------+
+```
+
+```sql
+select bitmap_union_count(user_id) from pv_bitmap where user_id is null;
+```
+
+```text
++-----------------------------+
+| bitmap_union_count(user_id) |
++-----------------------------+
+|                           0 |
++-----------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union-int.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union-int.md
new file mode 100644
index 00000000000..5f7ae0f263d
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union-int.md
@@ -0,0 +1,69 @@
+---
+{
+    "title": "BITMAP-UNION-INT",
+    "language": "ko",
+    "description": "입력 표현식에 포함된 고유한 값의 개수를 계산합니다. 반환 값은 COUNT(DISTINCT expr)와 같습니다."
+}
+---
+
+## 설명 {#description}
+
+입력 표현식에 포함된 고유한 값의 개수를 계산합니다. 반환 값은 COUNT(DISTINCT expr)와 같습니다.
+
+## 구문 {#syntax}
+
+```sql
+BITMAP_UNION_INT(<expr>)
+```
+
+## 인수 {#arguments}
+
+| 인수 | 설명 |
+| -- | -- |
+| `<expr>` | 입력 표현식입니다. 지원되는 타입: TinyInt, SmallInt, Integer. |
+
+## 반환 값 {#return-value}
+
+열에 있는 고유한 값의 개수를 반환합니다. 그룹에 유효한 데이터가 없으면 0을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE pv_bitmap (
+    dt INT,
+    page INT,
+    user_id BITMAP
+) DISTRIBUTED BY HASH(dt) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO pv_bitmap VALUES
+    (1, 100, to_bitmap(100)),
+    (1, 100, to_bitmap(200)),
+    (1, 100, to_bitmap(300)),
+    (1, 300, to_bitmap(300)),
+    (2, 200, to_bitmap(300));
+```
+
+```sql
+select bitmap_union_int(dt) from pv_bitmap;
+```
+
+```text
++----------------------+
+| bitmap_union_int(dt) |
++----------------------+
+|                    2 |
++----------------------+
+```
+
+```sql
+select bitmap_union_int(dt) from pv_bitmap where dt is null;
+```
+
+```text
++----------------------+
+| bitmap_union_int(dt) |
++----------------------+
+|                    0 |
++----------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union.md
new file mode 100644
index 00000000000..4f2d77a2f5b
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bitmap-union.md
@@ -0,0 +1,68 @@
+---
+{
+    "title": "BITMAP_UNION",
+    "language": "ko",
+    "description": "입력 Bitmap의 합집합을 계산하고 새로운 Bitmap을 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+입력 Bitmap의 합집합을 계산하고 새로운 Bitmap을 반환합니다.
+
+## 구문 {#syntax}
+
+```sql
+BITMAP_UNION(<expr>)
+```
+
+## 인수 {#arguments}
+
+| 인수 | 설명 |
+| -- | -- |
+| `<expr>` | Bitmap을 지원하는 데이터 타입 |
+
+## 반환값 {#return-value}
+
+Bitmap 타입의 값을 반환합니다. 그룹에 유효한 데이터가 없으면 빈 Bitmap을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE pv_bitmap (
+  dt INT,
+  page INT,
+  user_id BITMAP
+) DISTRIBUTED BY HASH(dt) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO pv_bitmap VALUES
+  (1, 100, to_bitmap(100)),
+  (1, 100, to_bitmap(200)),
+  (1, 100, to_bitmap(300)),
+  (2, 200, to_bitmap(300));
+```
+
+```sql
+select bitmap_to_string(bitmap_union(user_id)) from pv_bitmap;
+```
+
+```text
++-----------------------------------------+
+| bitmap_to_string(bitmap_union(user_id)) |
++-----------------------------------------+
+| 100,200,300                             |
++-----------------------------------------+
+```
+
+```sql
+select bitmap_to_string(bitmap_union(user_id)) from pv_bitmap where user_id is null;
+```
+
+```text
++-----------------------------------------+
+| bitmap_to_string(bitmap_union(user_id)) |
++-----------------------------------------+
+|                                         |
++-----------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-and.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-and.md
new file mode 100644
index 00000000000..7774bf73290
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-and.md
@@ -0,0 +1,146 @@
+---
+{
+    "title": "BOOL_AND",
+    "language": "ko",
+    "description": "표현식의 NULL이 아닌 모든 값에 대해 논리 AND 집계를 수행합니다."
+}
+---
+
+## 설명 {#description}
+
+표현식의 NULL이 아닌 모든 값에 대해 논리 AND 집계를 수행합니다.
+
+## 별칭 {#alias}
+
+- BOOLAND_AGG
+
+## 구문 {#syntax}
+
+```text
+BOOL_AND(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 논리 AND로 집계할 표현식입니다. BOOLEAN 타입과 0/non-0 규칙(0은 FALSE, 0이 아닌 값은 TRUE)에 따라 boolean으로 변환할 수 있는 숫자 타입을 지원합니다. |
+
+## 반환 값 {#return-value}
+
+반환 값의 타입은 BOOLEAN입니다. NULL이 아닌 모든 값이 TRUE일 때만 TRUE를 반환하며, 그렇지 않으면 FALSE를 반환합니다.
+
+표현식의 모든 값이 NULL이거나 표현식이 비어 있으면 NULL을 반환합니다.
+
+## 예제 {#examples}
+
+준비 :
+```sql
+CREATE TABLE IF NOT EXISTS test_boolean_agg (
+     id INT,
+     c1 BOOLEAN,
+     c2 BOOLEAN,
+     c3 BOOLEAN,
+     c4 BOOLEAN
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1"); 
+
+INSERT INTO test_boolean_agg (id, c1, c2, c3, c4) values 
+(1, true, true, true, false),
+(2, true, false, false, false),
+(3, true, true, false, false),
+(4, true, false, false, false);
+```
+
+### 집계 함수: {#aggregate-function}
+```sql
+SELECT booland_agg(c1), booland_agg(c2), booland_agg(c3), booland_agg(c4)
+FROM test_boolean_agg;
+```
+```text
++-----------------+-----------------+-----------------+-----------------+
+| booland_agg(c1) | booland_agg(c2) | booland_agg(c3) | booland_agg(c4) |
++-----------------+-----------------+-----------------+-----------------+
+|               1 |               0 |               0 |               0 |
++-----------------+-----------------+-----------------+-----------------+
+```
+
+bool_and는 숫자 타입의 매개변수도 받을 수 있으며, 숫자가 0이 아니면 `TRUE`로 변환됩니다.
+```sql
+CREATE TABLE test_numeric_and_null (
+    id INT,
+    c_int INT,
+    c_float FLOAT,
+    c_decimal DECIMAL(10,2),
+    c_bool BOOLEAN
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO test_numeric_and_null (id, c_int, c_float, c_decimal, c_bool) VALUES
+(1, 1, 1.0, NULL, NULL),
+(2, 0, NULL, 0.00, NULL),
+(3, 1, 3.14, 1.00, NULL),
+(4, 0, 1.0, 0.00, NULL),
+(5, NULL, NULL, NULL, NULL);
+```
+
+```sql
+SELECT
+    BOOL_AND(c_int) AS bool_and_int,
+    BOOL_AND(c_float) AS bool_and_float,
+    BOOL_AND(c_decimal) AS bool_and_decimal,
+    BOOL_AND(c_bool) AS bool_and_bool
+FROM test_numeric_and_null;
+```
+```text
++--------------+----------------+------------------+---------------+
+| bool_and_int | bool_and_float | bool_and_decimal | bool_and_bool |
++--------------+----------------+------------------+---------------+
+|            0 |              1 |                0 |          NULL |
++--------------+----------------+------------------+---------------+
+```
+
+### 윈도우 함수: {#window-function}
+다음 예제는 (id > 2) 조건에 따라 행을 두 그룹으로 나누고
+윈도우 집계 결과를 표시합니다:
+```sql
+SELECT * FROM test_boolean_agg;
+```
+```text
++------+------+------+------+------+
+| id   | c1   | c2   | c3   | c4   |
++------+------+------+------+------+
+|    1 |    1 |    1 |    1 |    0 |
+|    2 |    1 |    0 |    0 |    0 |
+|    3 |    1 |    1 |    0 |    0 |
+|    4 |    1 |    0 |    0 |    0 |
++------+------+------+------+------+
+```
+```sql
+SELECT
+    id,
+    BOOLAND_AGG(c1) OVER (PARTITION BY (id > 2)) AS a,
+    BOOLAND_AGG(c2) OVER (PARTITION BY (id > 2)) AS b,
+    BOOLAND_AGG(c3) OVER (PARTITION BY (id > 2)) AS c,
+    BOOLAND_AGG(c4) OVER (PARTITION BY (id > 2)) AS d
+FROM test_boolean_agg
+ORDER BY id;
+```
+```text
++------+------+------+------+------+
+| id   | a    | b    | c    | d    |
++------+------+------+------+------+
+|    1 |    1 |    0 |    0 |    0 |
+|    2 |    1 |    0 |    0 |    0 |
+|    3 |    1 |    0 |    0 |    0 |
+|    4 |    1 |    0 |    0 |    0 |
++------+------+------+------+------+
+```
+
+### 오류 예제: {#error-example}
+```sql
+SELECT BOOL_AND('invalid type');
+```
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = bool_and requires a boolean or numeric argument
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-or.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-or.md
new file mode 100644
index 00000000000..78baa6afdac
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-or.md
@@ -0,0 +1,147 @@
+---
+{
+    "title": "BOOL_OR",
+    "language": "ko",
+    "description": "표현식에서 NULL이 아닌 모든 값에 대해 논리 OR 집계를 수행합니다."
+}
+---
+
+## 설명 {#description}
+
+표현식에서 NULL이 아닌 모든 값에 대해 논리 OR 집계를 수행합니다.
+
+## 별칭 {#alias}
+
+- BOOLOR_AGG
+
+## 구문 {#syntax}
+
+```text
+BOOL_OR(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 논리 OR로 집계할 표현식입니다. BOOLEAN 타입과 0/non-0 규칙(0은 FALSE, 0이 아닌 값은 TRUE)에 따라 boolean으로 변환할 수 있는 숫자 타입을 지원합니다. |
+
+## 반환 값 {#return-value}
+
+반환 값의 타입은 BOOLEAN입니다. NULL이 아닌 값 중 하나 이상이 TRUE이면 TRUE를 반환하고, 그렇지 않으면 FALSE를 반환합니다.
+
+표현식의 모든 값이 NULL이거나 표현식이 비어 있으면 함수는 NULL을 반환합니다.
+
+## 예제 {#examples}
+
+준비 :
+```sql
+CREATE TABLE IF NOT EXISTS test_boolean_agg (
+     id INT,
+     c1 BOOLEAN,
+     c2 BOOLEAN,
+     c3 BOOLEAN,
+     c4 BOOLEAN
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1"); 
+
+INSERT INTO test_boolean_agg (id, c1, c2, c3, c4) values 
+(1, true, true, true, false),
+(2, true, false, false, false),
+(3, true, true, false, false),
+(4, true, false, false, false);
+```
+
+### 집계 함수: {#aggregate-function}
+```sql
+SELECT BOOLOR_AGG(c1), BOOLOR_AGG(c2), BOOLOR_AGG(c3), BOOLOR_AGG(c4)
+FROM test_boolean_agg;
+```
+```text
++----------------+----------------+----------------+----------------+
+| BOOLOR_AGG(c1) | BOOLOR_AGG(c2) | BOOLOR_AGG(c3) | BOOLOR_AGG(c4) |
++----------------+----------------+----------------+----------------+
+|              1 |              1 |              1 |              0 |
++----------------+----------------+----------------+----------------+
+```
+
+
+BOOL_OR는 숫자 타입도 지원하며, 영이 아닌 값은 `TRUE`로 처리됩니다:
+```sql
+CREATE TABLE test_numeric_or_null (
+    id INT,
+    c_int INT,
+    c_float FLOAT,
+    c_decimal DECIMAL(10,2),
+    c_bool BOOLEAN
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO test_numeric_or_null (id, c_int, c_float, c_decimal, c_bool) VALUES
+(1, 1, 1.0, NULL, NULL),
+(2, 0, NULL, 0.00, NULL),
+(3, 1, 3.14, 1.00, NULL),
+(4, 0, 1.0, 0.00, NULL),
+(5, NULL, NULL, NULL, NULL);
+```
+
+```sql
+SELECT
+    BOOL_OR(c_int) AS bool_or_int,
+    BOOL_OR(c_float) AS bool_or_float,
+    BOOL_OR(c_decimal) AS bool_or_decimal,
+    BOOL_OR(c_bool) AS bool_or_bool
+FROM test_numeric_or_null;
+```
+```text
++-------------+---------------+-----------------+--------------+
+| bool_or_int | bool_or_float | bool_or_decimal | bool_or_bool |
++-------------+---------------+-----------------+--------------+
+|           1 |             1 |               1 |         NULL |
++-------------+---------------+-----------------+--------------+
+```
+
+### 윈도우 함수: {#window-function}
+다음 예제는 (id > 2) 조건에 따라 행을
+두 그룹으로 분할하고, 윈도우 집계 결과를 표시합니다:
+```sql
+SELECT * FROM test_boolean_agg;
+```
+```text
++------+------+------+------+------+
+| id   | c1   | c2   | c3   | c4   |
++------+------+------+------+------+
+|    1 |    1 |    1 |    1 |    0 |
+|    2 |    1 |    0 |    0 |    0 |
+|    3 |    1 |    1 |    0 |    0 |
+|    4 |    1 |    0 |    0 |    0 |
++------+------+------+------+------+
+```
+```sql
+SELECT
+    id,
+    BOOLOR_AGG(c1) OVER (PARTITION BY (id > 2)) AS a,
+    BOOLOR_AGG(c2) OVER (PARTITION BY (id > 2)) AS b,
+    BOOLOR_AGG(c3) OVER (PARTITION BY (id > 2)) AS c,
+    BOOLOR_AGG(c4) OVER (PARTITION BY (id > 2)) AS d
+FROM test_boolean_agg
+ORDER BY id;
+```
+```text
++------+------+------+------+------+
+| id   | a    | b    | c    | d    |
++------+------+------+------+------+
+|    1 |    1 |    1 |    1 |    0 |
+|    2 |    1 |    1 |    1 |    0 |
+|    3 |    1 |    1 |    0 |    0 |
+|    4 |    1 |    1 |    0 |    0 |
++------+------+------+------+------+
+```
+
+### 오류 예제: {#error-example}
+```sql
+SELECT BOOL_OR('invalid type');
+```
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = bool_or requires a boolean or numeric argument
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-xor.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-xor.md
new file mode 100644
index 00000000000..4ea337c51d7
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/bool-xor.md
@@ -0,0 +1,147 @@
+---
+{
+    "title": "BOOL_XOR",
+    "language": "ko",
+    "description": "표현식의 NULL이 아닌 모든 값에 대해 논리 XOR 집계를 수행합니다."
+}
+---
+
+## 설명 {#description}
+
+표현식의 NULL이 아닌 모든 값에 대해 논리 XOR 집계를 수행합니다.
+
+## 별칭 {#alias}
+
+- BOOLXOR_AGG
+
+## 구문 {#syntax}
+
+```text
+BOOL_XOR(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 논리 XOR로 집계할 표현식입니다. BOOLEAN 타입과 0/non-0 규칙(0은 FALSE, non-0은 TRUE)에 따라 boolean으로 변환할 수 있는 숫자 타입을 지원합니다. |
+
+## 반환값 {#return-value}
+
+반환값의 타입은 BOOLEAN입니다. NULL이 아닌 모든 값 중 TRUE가 하나만 있으면 TRUE를 반환하고, 그 외에는 FALSE를 반환합니다.
+
+표현식의 모든 값이 NULL이거나 표현식이 비어 있으면 이 함수는 NULL을 반환합니다.
+
+## 예제 {#examples}
+
+테이블 초기화:
+```sql
+CREATE TABLE IF NOT EXISTS test_boolean_agg (
+     id INT,
+     c1 BOOLEAN,
+     c2 BOOLEAN,
+     c3 BOOLEAN,
+     c4 BOOLEAN
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1"); 
+
+INSERT INTO test_boolean_agg (id, c1, c2, c3, c4) values 
+(1, true, true, true, false),
+(2, true, false, false, false),
+(3, true, true, false, false),
+(4, true, false, false, false);
+```
+
+### 집계 함수 {#aggregate-function}
+
+```sql
+SELECT BOOLXOR_AGG(c1), BOOLXOR_AGG(c2), BOOLXOR_AGG(c3), BOOLXOR_AGG(c4)
+FROM test_boolean_agg;
+```
+```text
++-----------------+-----------------+-----------------+-----------------+
+| BOOLXOR_AGG(c1) | BOOLXOR_AGG(c2) | BOOLXOR_AGG(c3) | BOOLXOR_AGG(c4) |
++-----------------+-----------------+-----------------+-----------------+
+|               0 |               0 |               1 |               0 |
++-----------------+-----------------+-----------------+-----------------+
+```
+
+BOOL_XOR는 숫자 타입도 입력받으며, 영이 아닌 값은 TRUE로 처리합니다:
+```sql
+CREATE TABLE test_numeric_and_null (
+    id INT,
+    c_int INT,
+    c_float FLOAT,
+    c_decimal DECIMAL(10,2),
+    c_bool BOOLEAN
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO test_numeric_and_null (id, c_int, c_float, c_decimal, c_bool) VALUES
+(1, 1, 1.0, NULL, NULL),
+(2, 0, NULL, 0.00, NULL),
+(3, 1, 3.14, 1.00, NULL),
+(4, 0, 1.0, 0.00, NULL),
+(5, NULL, NULL, NULL, NULL);
+```
+
+```sql
+SELECT
+    BOOL_XOR(c_int) AS bool_xor_int,
+    BOOL_XOR(c_float) AS bool_xor_float,
+    BOOL_XOR(c_decimal) AS bool_xor_decimal,
+    BOOL_XOR(c_bool) AS bool_xor_bool
+FROM test_numeric_and_null;
+```
+```text
++--------------+----------------+------------------+---------------+
+| bool_xor_int | bool_xor_float | bool_xor_decimal | bool_xor_bool |
++--------------+----------------+------------------+---------------+
+|            0 |              0 |                1 |          NULL |
++--------------+----------------+------------------+---------------+
+```
+
+### 윈도우 함수 {#window-function}
+다음 예제는 (id > 2) 조건에 따라 행을 두 그룹으로 나누고,
+윈도우 집계 결과를 표시합니다:
+```sql
+SELECT * FROM test_boolean_agg;
+```
+```text
++------+------+------+------+------+
+| id   | c1   | c2   | c3   | c4   |
++------+------+------+------+------+
+|    1 |    1 |    1 |    1 |    0 |
+|    2 |    1 |    0 |    0 |    0 |
+|    3 |    1 |    1 |    0 |    0 |
+|    4 |    1 |    0 |    0 |    0 |
++------+------+------+------+------+
+```
+```sql
+SELECT
+    id,
+    BOOLXOR_AGG(c1) OVER (PARTITION BY (id > 2)) AS a,
+    BOOLXOR_AGG(c2) OVER (PARTITION BY (id > 2)) AS b,
+    BOOLXOR_AGG(c3) OVER (PARTITION BY (id > 2)) AS c,
+    BOOLXOR_AGG(c4) OVER (PARTITION BY (id > 2)) AS d
+FROM test_boolean_agg
+ORDER BY id;
+```
+```text
++------+------+------+------+------+
+| id   | a    | b    | c    | d    |
++------+------+------+------+------+
+|    1 |    0 |    1 |    1 |    0 |
+|    2 |    0 |    1 |    1 |    0 |
+|    3 |    0 |    1 |    0 |    0 |
+|    4 |    0 |    1 |    0 |    0 |
++------+------+------+------+------+
+```
+
+### 오류 예제: {#error-example}
+```sql
+SELECT BOOL_XOR('invalid type');
+```
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = bool_xor requires a boolean or numeric argument
+``` 
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/collect-list.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/collect-list.md
new file mode 100644
index 00000000000..4ce7a0b6f6d
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/collect-list.md
@@ -0,0 +1,71 @@
+---
+{
+    "title": "COLLECT_LIST",
+    "language": "ko",
+    "description": "열의 모든 값을 배열로 집계하는 집계 함수입니다."
+}
+---
+
+## 설명 {#description}
+
+열의 모든 값을 배열로 집계하는 집계 함수입니다.
+
+## 별칭 {#alias}
+
+- GROUP_ARRAY
+
+## 구문 {#syntax}
+
+```sql
+COLLECT_LIST(<expr> [,<max_size>])
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 배열에 넣을 값을 결정하는 표현식입니다. 지원되는 타입: Bool, TinyInt, SmallInt, Integer, BigInt, LargeInt, Float, Double, Decimal, Date, Datetime, Timestamptz, IPV4, IPV6, String, Array, Map, Struct. |
+| `<max_size>` | 결과 배열의 요소 수를 max_size개로 제한하는 선택적 매개변수입니다. 지원되는 타입: Integer. |
+
+## 반환 값 {#return-value}
+
+NULL이 아닌 모든 값을 포함하는 ARRAY 타입을 반환합니다. 그룹에 유효한 데이터가 없으면 빈 배열을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE collect_list_test (
+	k1 INT,
+	k2 INT,
+	k3 STRING
+) DISTRIBUTED BY HASH(k1) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO collect_list_test VALUES (1, 10, 'a'), (1, 20, 'b'), (1, 30, 'c'), (2, 100, 'x'), (2, 200, 'y'), (3, NULL, NULL);
+```
+
+```sql
+select collect_list(k1),collect_list(k1,3) from collect_list_test;
+```
+
+```text
++--------------------+--------------------+
+| collect_list(k1)   | collect_list(k1,3) |
++--------------------+--------------------+
+| [1, 1, 1, 2, 2, 3] | [1, 1, 1]          |
++--------------------+--------------------+
+```
+
+```sql
+select k1,collect_list(k2),collect_list(k3,1) from collect_list_test group by k1 order by k1;
+```
+
+```text
++------+------------------+--------------------+
+| k1   | collect_list(k2) | collect_list(k3,1) |
++------+------------------+--------------------+
+|    1 | [10, 20, 30]     | ["a"]              |
+|    2 | [100, 200]       | ["x"]              |
+|    3 | []               | []                 |
++------+------------------+--------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/collect-set.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/collect-set.md
new file mode 100644
index 00000000000..968aa979e4d
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/collect-set.md
@@ -0,0 +1,71 @@
+---
+{
+    "title": "COLLECT_SET",
+    "language": "ko",
+    "description": "집계 함수는 지정된 컬럼의 고유한 값을 모두 집계하고 중복 요소를 제거한 후 집합 타입의 결과를 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+집계 함수는 지정된 컬럼의 고유한 값을 모두 집계하고 중복 요소를 제거한 후 집합 타입의 결과를 반환합니다.
+
+## 별칭 {#alias}
+
+- GROUP_UNIQ_ARRAY
+
+## 구문 {#syntax}
+
+```sql
+COLLECT_SET(<expr> [,<max_size>])
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 배열에 넣을 값을 결정하는 표현식입니다. 지원되는 타입: Bool, TinyInt, SmallInt, Integer, BigInt, LargeInt, Float, Double, Decimal, Date, Datetime, Timestamptz, IPV4, IPV6, String, Array, Map, Struct. |
+| `<max_size>` | 결과 배열의 요소 수를 max_size로 제한하는 선택적 매개변수입니다. 지원되는 타입: Integer. |
+
+## 반환 값 {#return-value}
+
+중복을 제거한 후 NULL이 아닌 모든 값을 포함하는 ARRAY 타입을 반환합니다. 그룹에 유효한 데이터가 없으면 빈 배열을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE collect_set_test (
+	k1 INT,
+	k2 INT,
+	k3 STRING
+) DISTRIBUTED BY HASH(k1) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO collect_set_test VALUES (1, 10, 'a'), (1, 20, 'b'), (1, 10, 'a'), (2, 100, 'x'), (2, 200, 'y'), (3, NULL, NULL);
+```
+
+```sql
+select collect_set(k1),collect_set(k1,2) from collect_set_test;
+```
+
+```text
++-----------------+-------------------+
+| collect_set(k1) | collect_set(k1,2) |
++-----------------+-------------------+
+| [2, 1, 3]       | [2, 1]            |
++-----------------+-------------------+
+```
+
+```sql
+select k1,collect_set(k2),collect_set(k3,1) from collect_set_test group by k1 order by k1;
+```
+
+```text
++------+-----------------+-------------------+
+| k1   | collect_set(k2) | collect_set(k3,1) |
++------+-----------------+-------------------+
+|    1 | [20, 10]        | ["a"]             |
+|    2 | [200, 100]      | ["x"]             |
+|    3 | []              | []                |
++------+-----------------+-------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/corr-welford.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/corr-welford.md
new file mode 100644
index 00000000000..5cd6a5c5c98
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/corr-welford.md
@@ -0,0 +1,104 @@
+---
+{
+    "title": "CORR_WELFORD",
+    "language": "ko",
+    "description": "Welford 알고리즘을 사용하여 두 확률 변수 사이의 Pearson 상관 계수를 계산하며, 계산 오차를 효과적으로 줄입니다."
+}
+---
+
+## 설명 {#description}
+
+[Welford](https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm) 알고리즘을 사용하여 두 확률 변수 사이의 Pearson 상관 계수를 계산하며, 계산 오차를 효과적으로 줄입니다.
+
+## 구문 {#syntax}
+
+```sql
+CORR_WELFORD(<expr1>, <expr2>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr1>` | Double 표현식(열) |
+| `<expr2>` | Double 표현식(열) |
+
+## 반환값 {#return-value}
+
+expr1과 expr2의 공분산을 각 표준편차의 곱으로 나눈 DOUBLE 타입 값을 반환합니다. 특수한 경우는 다음과 같습니다.
+
+- expr1 또는 expr2의 표준편차가 0이면 0을 반환합니다.
+- expr1 또는 expr2에 NULL 값이 포함되어 있으면 해당 행은 최종 결과에서 제외됩니다.
+- 그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table test_corr(
+    id int,
+    k1 double,
+    k2 double
+) distributed by hash (id) buckets 1
+properties ("replication_num"="1");
+
+insert into test_corr values 
+    (1, 20, 22),
+    (1, 10, 20),
+    (2, 36, 21),
+    (2, 30, 22),
+    (2, 25, 20),
+    (3, 25, NULL),
+    (4, 25, 21),
+    (4, 25, 22),
+    (4, 25, 20);
+```
+
+```sql
+select * from test_corr order by id, k1, k2;
+```
+
+```text
++------+------+------+
+| id   | k1   | k2   |
++------+------+------+
+|    1 |   10 |   20 |
+|    1 |   20 |   22 |
+|    2 |   25 |   20 |
+|    2 |   30 |   22 |
+|    2 |   36 |   21 |
+|    3 |   25 | NULL |
+|    4 |   25 |   20 |
+|    4 |   25 |   21 |
+|    4 |   25 |   22 |
++------+------+------+
+```
+
+```sql
+select id, corr_welford(k1, k2) from test_corr group by id order by id;
+```
+
+```text
++------+----------------------+
+| id   | corr_welford(k1, k2) |
++------+----------------------+
+|    1 |                    1 |
+|    2 |   0.4539206495016017 |
+|    3 |                 NULL |
+|    4 |                    0 |
++------+----------------------+
+```
+
+그룹에 유효한 `(k1, k2)` 쌍이 없으면(여기서는 `id = 999`와 일치하는 행이 없음) 집계 함수는 NULL을 반환합니다.
+
+```sql
+select corr_welford(k1, k2) from test_corr where id = 999;
+```
+
+```text
++----------------------+
+| corr_welford(k1, k2) |
++----------------------+
+|                 NULL |
++----------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/corr.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/corr.md
new file mode 100644
index 00000000000..51a39fc3a63
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/corr.md
@@ -0,0 +1,84 @@
+---
+{
+    "title": "CORR",
+    "language": "ko",
+    "description": "두 확률 변수 간의 피어슨 상관 계수를 계산합니다."
+}
+---
+
+## 설명 {#description}
+
+두 확률 변수 간의 피어슨 상관 계수를 계산합니다.
+
+## 구문 {#syntax}
+
+```sql
+CORR(<expr1>, <expr2>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr1>` | 계산에 사용할 표현식입니다. 지원하는 타입은 Double입니다. |
+| `<expr2>` | 계산에 사용할 표현식입니다. 지원하는 타입은 Double입니다. |
+
+## 반환값 {#return-value}
+
+DOUBLE 타입의 값을 반환합니다. 이 값은 expr1과 expr2의 공분산을 두 변수의 표준편차의 곱으로 나눈 값입니다. 특수한 경우는 다음과 같습니다.
+
+- expr1 또는 expr2의 표준편차가 0이면 0을 반환합니다.
+- expr1 또는 expr2에 NULL 값이 포함되어 있으면 해당 행은 계산에서 제외됩니다.
+- 그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table test_corr(
+    id int,
+    k1 double,
+    k2 double
+) distributed by hash (id) buckets 1
+properties ("replication_num"="1");
+
+insert into test_corr values 
+    (1, 20, 22),
+    (1, 10, 20),
+    (2, 36, 21),
+    (2, 30, 22),
+    (2, 25, 20),
+    (3, 25, NULL),
+    (4, 25, 21),
+    (4, 25, 22),
+    (4, 25, 20);
+```
+
+```sql
+select id,corr(k1,k2) from test_corr group by id;
+```
+
+```text
++------+--------------------+
+| id   | corr(k1, k2)       |
++------+--------------------+
+|    4 |                  0 |
+|    1 |                  1 |
+|    3 |               NULL |
+|    2 | 0.4539206495016019 |
++------+--------------------+
+```
+
+```sql
+select corr(k1,k2) from test_corr where id=999;
+```
+
+쿼리 결과가 비어 있으면 NULL을 반환합니다.
+
+```text
++-------------+
+| corr(k1,k2) |
++-------------+
+|        NULL |
++-------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count-by-enum.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count-by-enum.md
new file mode 100644
index 00000000000..23dffb9f135
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count-by-enum.md
@@ -0,0 +1,146 @@
+---
+{
+    "title": "COUNT_BY_ENUM",
+    "language": "ko",
+    "description": "컬럼의 데이터를 열거 값으로 취급하여 각 열거 값의 개수를 계산합니다."
+}
+---
+
+## 설명 {#description}
+
+컬럼의 데이터를 열거 값으로 취급하여 각 열거 값의 개수를 계산합니다. 각 컬럼의 열거 값별 개수와 NULL이 아닌 값의 개수, NULL 값의 개수를 반환합니다.
+
+## 구문 {#syntax}
+
+```sql
+COUNT_BY_ENUM(<expr1>, <expr2>, ... , <exprN>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr1>` | 입력이 최소 하나 필요하며, 최대 1024개의 입력을 지원합니다. 지원되는 타입은 String입니다. |
+
+## 반환 값 {#return-value}
+
+결과를 JSONArray 형식으로 반환합니다.
+반환 타입은 String입니다.
+
+예를 들면 다음과 같습니다.
+```json
+[{
+  "cbe": {
+    "F": 100,
+    "M": 99
+  },
+  "notnull": 199,
+  "null": 1,
+  "all": 200
+}, {
+  "cbe": {
+    "20": 10,
+    "30": 5,
+    "35": 1
+  },
+  "notnull": 16,
+  "null": 184,
+  "all": 200
+}, {
+  "cbe": {
+    "China": 10,
+    "United States": 9,
+    "England": 20,
+    "Germany": 30
+  },
+  "notnull": 69,
+  "null": 131,
+  "all": 200
+}]
+```
+설명: 반환 값은 JSON 배열 문자열이며, 내부 객체의 순서는 입력 매개변수의 순서를 따릅니다.
+* cbe: 열거 값별로 집계한 NULL이 아닌 값의 통계 결과
+* notnull: NULL이 아닌 값의 개수
+* null: NULL 값의 개수
+* all: NULL 값과 NULL이 아닌 값을 모두 포함한 전체 개수.
+
+
+## 예제 {#example}
+
+결과에서 JSON 객체의 순서는 일정하지 않으므로, 결과는 다음과 같을 수 있습니다.
+
+```sql
+CREATE TABLE count_by_enum_test(
+                                   `id` varchar(1024) NULL,
+                                   `f1` text REPLACE_IF_NOT_NULL NULL,
+                                   `f2` text REPLACE_IF_NOT_NULL NULL,
+                                   `f3` text REPLACE_IF_NOT_NULL NULL
+)
+AGGREGATE KEY(`id`)
+DISTRIBUTED BY HASH(id) BUCKETS 3 
+PROPERTIES ( 
+    "replication_num" = "1"
+);
+```
+
+```sql
+INSERT into count_by_enum_test (id, f1, f2, f3) values
+                                                    (1, "F", "10", "China"),
+                                                    (2, "F", "20", "China"),
+                                                    (3, "M", NULL, "United States"),
+                                                    (4, "M", NULL, "United States"),
+                                                    (5, "M", NULL, "England");
+```
+
+
+```sql
+SELECT * from count_by_enum_test;
+```
+
+```text
++------+------+------+---------------+
+| id   | f1   | f2   | f3            |
++------+------+------+---------------+
+| 1    | F    | 10   | China         |
+| 2    | F    | 20   | China         |
+| 3    | M    | NULL | United States |
+| 4    | M    | NULL | United States |
+| 5    | M    | NULL | England       |
++------+------+------+---------------+
+```
+
+```sql
+select count_by_enum(f1) from count_by_enum_test;
+```
+
+```text
++------------------------------------------------------+
+| count_by_enum(`f1`)                                  |
++------------------------------------------------------+
+| [{"cbe":{"M":3,"F":2},"notnull":5,"null":0,"all":5}] |
++------------------------------------------------------+
+```
+
+```sql
+select count_by_enum(f2) from count_by_enum_test;
+```
+
+```text
++--------------------------------------------------------+
+| count_by_enum(`f2`)                                    |
++--------------------------------------------------------+
+| [{"cbe":{"10":1,"20":1},"notnull":2,"null":3,"all":5}] |
++--------------------------------------------------------+
+```
+
+```sql
+select count_by_enum(f1,f2,f3) from count_by_enum_test;
+```
+
+```text
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| count_by_enum(`f1`, `f2`, `f3`)                                                                                                                                                          |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| [{"cbe":{"M":3,"F":2},"notnull":5,"null":0,"all":5},{"cbe":{"20":1,"10":1},"notnull":2,"null":3,"all":5},{"cbe":{"England":1,"United States":2,"China":2},"notnull":5,"null":0,"all":5}] |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count-map.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count-map.md
new file mode 100644
index 00000000000..64bec56686c
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count-map.md
@@ -0,0 +1,115 @@
+---
+{
+    "title": "COUNT_MAP",
+    "language": "ko",
+    "description": "COUNT_MAP 함수는 MAP 값을 키별로 집계하고 각 키에서 NULL이 아닌 값의 개수를 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+COUNT_MAP 함수는 MAP 값을 키별로 집계하고 각 키에서 NULL이 아닌 값의 개수를 담은 MAP을 반환합니다.
+
+## 사용 시 유의 사항 {#usage-notes}
+
+반환된 MAP의 항목 순서는 보장되지 않습니다. 일정한 출력 순서가 필요하면 `map_keys`, `map_values`, `array_sort`, `array_sortby`를 사용하세요. NULL 키도 일반 키와 동일하게 집계되며, 모든 NULL 키는 하나의 결과 항목에 속합니다.
+
+## 구문 {#syntax}
+
+```sql
+COUNT_MAP(<map_expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| --- | --- |
+| `<map_expr>` | MAP 표현식. |
+
+## 반환 값 {#return-value}
+
+`<map_expr>`와 키 타입이 같고 값 타입이 BIGINT인 MAP을 반환합니다.
+
+그룹에 유효한 입력 행이 없으면 빈 MAP을 반환합니다. 키가 존재하지만 해당 키의 값이 모두 NULL이면 해당 키의 값은 0입니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE map_agg_example (
+    id INT,
+    m MAP<INT, INT>,
+    ms MAP<INT, STRING>
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO map_agg_example VALUES
+    (1, MAP(1, 10, 2, 20), MAP(1, 'b', 2, 'x')),
+    (1, MAP(2, 5, 3, 30), MAP(1, 'a', 3, NULL)),
+    (2, MAP(1, 7, 4, NULL), MAP(2, 'z')),
+    (2, CAST(MAP() AS MAP<INT, INT>), CAST(MAP() AS MAP<INT, STRING>));
+```
+
+```text
+Query OK
+```
+
+```sql
+SELECT id,
+       array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT id, COUNT_MAP(m) AS result
+    FROM map_agg_example
+    GROUP BY id
+) t
+ORDER BY id;
+```
+
+```text
++------+-----------+-----------+
+| id   | keys      | values    |
++------+-----------+-----------+
+|    1 | [1, 2, 3] | [1, 2, 1] |
+|    2 | [1, 4]    | [1, 0]    |
++------+-----------+-----------+
+```
+
+```sql
+SELECT id,
+       array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT id, COUNT_MAP(ms) AS result
+    FROM map_agg_example
+    GROUP BY id
+) t
+ORDER BY id;
+```
+
+```text
++------+-----------+-----------+
+| id   | keys      | values    |
++------+-----------+-----------+
+|    1 | [1, 2, 3] | [2, 1, 0] |
+|    2 | [2]       | [1]       |
++------+-----------+-----------+
+```
+
+```sql
+SELECT array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT COUNT_MAP(m) AS result
+    FROM map_agg_example
+    WHERE id = 100
+) t;
+```
+
+```text
++------+--------+
+| keys | values |
++------+--------+
+| []   | []     |
++------+--------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count.md
new file mode 100644
index 00000000000..19a7d611f2d
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/count.md
@@ -0,0 +1,112 @@
+---
+{
+    "title": "COUNT",
+    "language": "ko",
+    "description": "지정된 열에서 NULL이 아닌 레코드 수 또는 전체 레코드 수를 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+지정된 열에서 NULL이 아닌 레코드 수 또는 전체 레코드 수를 반환합니다.
+
+## 구문 {#syntax}
+
+```sql
+COUNT(DISTINCT <expr> [,<expr>,...])
+COUNT(*)
+COUNT(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 표현식을 지정하면 NULL이 아닌 레코드 수를 세고, 지정하지 않으면 전체 행 수를 셉니다. |
+
+## 반환 값 {#return-value}
+
+반환 타입은 Bigint입니다. expr이 NULL이면 집계하지 않습니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table test_count(
+    id int,
+    name varchar(20),
+    sex int
+) distributed by hash(id) buckets 1
+properties ("replication_num"="1");
+
+insert into test_count values
+    (1, '1', 1),
+    (2, '2', 1),
+    (3, '3', 1),
+    (4, '0', 1),
+    (4, '4', 1),
+    (5, NULL, 1);
+
+create table test_insert(
+    id int,
+    name varchar(20),
+    sex int
+) distributed by hash(id) buckets 1
+properties ("replication_num"="1");
+
+insert into test_insert values
+    (1, '1', 1),
+    (2, '2', 1),
+    (3, '3', 1),
+    (4, '0', 1),
+    (4, '4', 1),
+    (5, NULL, 1);
+```
+
+```sql
+select count(*) from test_count;
+```
+
+```text
++----------+
+| count(*) |
++----------+
+|        6 |
++----------+
+```
+
+```sql
+select count(name) from test_insert;
+```
+
+```text
++-------------+
+| count(name) |
++-------------+
+|           5 |
++-------------+
+```
+
+```sql
+select count(distinct sex) from test_insert;
+```
+
+```text
++---------------------+
+| count(DISTINCT sex) |
++---------------------+
+|                   1 |
++---------------------+
+```
+
+```sql
+select count(distinct id,sex) from test_insert;
+```
+
+```text
++-------------------------+
+| count(DISTINCT id, sex) |
++-------------------------+
+|                       5 |
++-------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/covar-samp.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/covar-samp.md
new file mode 100644
index 00000000000..45257606c00
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/covar-samp.md
@@ -0,0 +1,76 @@
+---
+{
+    "title": "COVAR_SAMP",
+    "language": "ko",
+    "description": "두 변수 간의 표본 공분산을 계산합니다. 입력 변수 중 하나라도 NULL이면 해당 행은 계산에서 제외됩니다."
+}
+---
+
+## 설명 {#description}
+
+두 변수 간의 표본 공분산을 계산합니다. 입력 변수 중 하나라도 NULL이면 해당 행은 계산에서 제외됩니다.
+
+## 구문 {#syntax}
+
+```sql
+COVAR_SAMP(<expr1>, <expr2>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr1>` | 계산할 표현식 중 하나로, 지원되는 타입은 Double입니다. |
+| `<expr2>` | 계산할 표현식 중 하나로, 지원되는 타입은 Double입니다. |
+
+## 반환 값 {#return-value}
+
+expr1과 expr2의 표본 공분산을 반환하며, 반환 타입은 Double입니다.
+그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table baseall(
+    id int,
+    x double,
+    y double
+) distributed by hash(id) buckets 1
+properties ("replication_num"="1");
+
+insert into baseall values
+    (1, 1.0, 2.0),
+    (2, 2.0, 3.0),
+    (3, 3.0, 4.0),
+    (4, 4.0, NULL),
+    (5, NULL, 5.0);
+```
+
+```sql
+select covar_samp(x,y) from baseall;
+```
+
+```text
++-----------------+
+| covar_samp(x,y) |
++-----------------+
+|               1 |
++-----------------+
+```
+
+```sql
+select id, covar_samp(x, y) from baseall group by id;
+```
+
+```text
++------+------------------+
+| id   | covar_samp(x, y) |
++------+------------------+
+|    1 |                0 |
+|    2 |                0 |
+|    3 |                0 |
+|    4 |             NULL |
+|    5 |             NULL |
++------+------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/covar.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/covar.md
new file mode 100644
index 00000000000..fcecfc9f2f0
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/covar.md
@@ -0,0 +1,81 @@
+---
+{
+    "title": "COVAR",
+    "language": "ko",
+    "description": "두 변수 간의 표본 공분산을 계산합니다. 입력 변수 중 하나라도 NULL이면 해당 행은 계산에 포함되지 않습니다."
+}
+---
+
+## 설명 {#description}
+
+두 변수 간의 표본 공분산을 계산합니다. 입력 변수 중 하나라도 NULL이면 해당 행은 계산에 포함되지 않습니다.
+
+## 별칭 {#alias}
+
+- COVAR_POP
+
+## 구문 {#syntax}
+
+```sql
+COVAR(<expr1>, <expr2>)
+COVAR_POP(<expr1>, <expr2>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr1>` | 계산할 표현식 중 하나로, 지원되는 타입은 Double입니다. |
+| `<expr2>` | 계산할 표현식 중 하나로, 지원되는 타입은 Double입니다. |
+
+## 반환 값 {#return-value}
+
+expr1과 expr2의 표본 공분산을 반환하며, 반환 타입은 Double입니다.
+그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table baseall(
+    id int,
+    x double,
+    y double
+) distributed by hash(id) buckets 1
+properties ("replication_num"="1");
+
+insert into baseall values
+    (1, 1.0, 2.0),
+    (2, 2.0, 3.0),
+    (3, 3.0, 4.0),
+    (4, 4.0, NULL),
+    (5, NULL, 5.0);
+```
+
+```sql
+select covar(x,y) from baseall;
+```
+
+```text
++-------------------+
+| covar(x,y)        |
++-------------------+
+| 0.666666666666667 |
++-------------------+
+```
+
+```sql
+select id, covar(x, y) from baseall group by id;
+```
+
+```text
++------+-------------+
+| id   | covar(x, y) |
++------+-------------+
+|    1 |           0 |
+|    2 |           0 |
+|    3 |           0 |
+|    4 |        NULL |
+|    5 |        NULL |
++------+-------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/datasketches_hll_union_agg.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/datasketches_hll_union_agg.md
new file mode 100644
index 00000000000..24b040a9735
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/datasketches_hll_union_agg.md
@@ -0,0 +1,120 @@
+---
+{
+    "title": "DATASKETCHES_HLL_UNION_AGG",
+    "language": "ko",
+    "description": "datasketches_hll_union_agg 함수는 여러 Apache DataSketches HLL 스케치를 합집합으로 결합하고 합집합의 추정 카디널리티를 DOUBLE 값으로 반환하는 집계 함수입니다."
+}
+---
+
+> 버전 4.1.2부터 지원됩니다.
+
+## 설명 {#description}
+
+`datasketches_hll_union_agg`는 여러 Apache DataSketches **HLL** (`hll_sketch`) 직렬화 값을 **합집합으로 결합**하고 결합 결과의 **추정 카디널리티**(근사 고유 값 개수 / NDV)를 반환하는 집계 함수입니다.
+
+이 함수는 **DataSketches HLL 스케치를 직렬화한 바이트**를 입력으로 받습니다(예: DataSketches 라이브러리의 `hll_sketch.serialize_compact()`로 생성한 값). 임의의 문자열은 허용하지 않습니다.
+
+## 별칭 {#alias}
+
+- `ds_hll_estimate`
+- `datasketches_hll_estimate`
+
+## 구문 {#syntax}
+
+```sql
+datasketches_hll_union_agg(<sketch>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<sketch>` | Apache DataSketches HLL 스케치를 직렬화한 바이트입니다. 지원되는 타입: STRING / VARCHAR / VARBINARY. NULL 값은 무시됩니다. 빈 문자열은 유효하지 않은 입력으로 처리되며 오류가 발생합니다. |
+
+## 반환 값 {#return-value}
+
+DOUBLE (Float64) 타입의 카디널리티 추정값을 반환합니다.  
+그룹에 유효한 데이터가 없거나 입력이 비어 있으면 0을 반환합니다.  
+입력 바이트를 유효한 DataSketches HLL 스케치로 역직렬화할 수 없으면(빈 문자열 포함) 오류가 발생합니다(일반적으로 오류 코드는 `CORRUPTION`).
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE test_datasketches_hll_union_agg_tbl (
+    id INT,
+    sk STRING
+)
+DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+-- The sketch bytes are inserted via Base64 decoding.
+INSERT INTO test_datasketches_hll_union_agg_tbl VALUES
+    (1, from_base64('AgEHCAMIBwjL18IEK/L7BoYv+Q11gWYHgbxdBntl5gj8LUIK')),
+    (2, from_base64('AwEHCAUIAAkKAAAAIjvrBcS1nwfGGWoEyHokBO8t9wc1qTEENkcJB7hWqQxZf9QNnuSbGA==')),
+    (3, NULL);
+```
+
+```sql
+-- The function returns DOUBLE, so use ROUND/CAST if you want an integer display.
+SELECT CAST(ROUND(datasketches_hll_union_agg(sk)) AS BIGINT)
+FROM test_datasketches_hll_union_agg_tbl;
+```
+
+```text
++-------------------------------------------------------+
+| CAST(ROUND(datasketches_hll_union_agg(sk)) AS BIGINT) |
++-------------------------------------------------------+
+|                                                    17 |
++-------------------------------------------------------+
+```
+
+```sql
+-- aliases
+SELECT
+    CAST(ROUND(datasketches_hll_union_agg(sk)) AS BIGINT) AS v1,
+    CAST(ROUND(ds_hll_estimate(sk)) AS BIGINT)            AS v2,
+    CAST(ROUND(datasketches_hll_estimate(sk)) AS BIGINT)  AS v3
+FROM test_datasketches_hll_union_agg_tbl;
+```
+
+```text
++------+------+------+
+| v1   | v2   | v3   |
++------+------+------+
+|   17 |   17 |   17 |
++------+------+------+
+```
+
+```sql
+-- empty input returns 0
+SELECT datasketches_hll_union_agg(sk)
+FROM test_datasketches_hll_union_agg_tbl
+WHERE sk IS NULL;
+```
+
+```text
++--------------------------------+
+| datasketches_hll_union_agg(sk) |
++--------------------------------+
+|                              0 |
++--------------------------------+
+```
+
+```sql
+-- invalid sketch bytes will throw
+SELECT datasketches_hll_union_agg(from_base64('AA=='));
+```
+
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (127.0.0.1)[CORRUPTION]HLL sketch data corrupted when add: Attempt to deserialize unknown object type
+```
+
+```sql
+-- empty string is invalid and will throw
+SELECT datasketches_hll_union_agg('');
+```
+
+```text
+ERROR 1105 (HY000): errCode = 2, detailMessage = (127.0.0.1)[CORRUPTION]HLL sketch data corrupted when add: empty input.
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-array-intersect.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-array-intersect.md
new file mode 100644
index 00000000000..288663d946b
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-array-intersect.md
@@ -0,0 +1,66 @@
+---
+{
+    "title": "GROUP_ARRAY_INTERSECT",
+    "language": "ko",
+    "description": "모든 행에 걸쳐 입력 배열의 교집합을 구하고 새 배열로 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+모든 행에 걸쳐 입력 배열의 교집합을 구하고 새 배열로 반환합니다.
+
+## 구문 {#syntax}
+
+```sql
+GROUP_ARRAY_INTERSECT(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 교집합을 구할 표현식입니다. 지원되는 타입: Array. |
+
+## 반환 값 {#return-value}
+
+교집합 결과를 포함하는 배열을 반환합니다. 그룹에 유효한 데이터가 없으면 빈 배열을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE group_array_intersect_test (
+    id INT,
+    c_array_string ARRAY<STRING>
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO group_array_intersect_test VALUES
+    (1, ['a', 'b', 'c', 'd', 'e']),
+    (2, ['a', 'b']),
+    (3, ['a', null]);
+```
+
+```sql
+select group_array_intersect(c_array_string) from group_array_intersect_test;
+```
+
+```text
++---------------------------------------+
+| group_array_intersect(c_array_string) |
++---------------------------------------+
+| ["a"]                                 |
++---------------------------------------+
+```
+
+```sql
+select group_array_intersect(c_array_string) from group_array_intersect_test where id is null;
+```
+
+```text
++---------------------------------------+
+| group_array_intersect(c_array_string) |
++---------------------------------------+
+| []                                    |
++---------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-array-union.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-array-union.md
new file mode 100644
index 00000000000..2273742a884
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-array-union.md
@@ -0,0 +1,80 @@
+---
+{
+    "title": "GROUP_ARRAY_UNION",
+    "language": "ko",
+    "description": "입력 배열의 각 행에 있는 모든 요소를 중복 없이 합친 새 배열을 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+입력 배열의 각 행에 있는 모든 요소를 중복 없이 합친 새 배열을 반환합니다.
+
+## 구문 {#syntax}
+
+```sql
+GROUP_ARRAY_UNION(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 합집합을 계산할 표현식입니다. 지원되는 타입은 Array<Type>입니다. Array 내에 복합 타입을 중첩하는 것은 지원하지 않습니다. |
+
+## 반환 값 {#return-value}
+
+합집합 결과를 담은 배열을 반환합니다. 그룹에 유효한 데이터가 없으면 빈 배열을 반환합니다.
+
+## 예제 {#example}
+
+
+```sql
+-- setup
+CREATE TABLE group_array_union_test (
+	id INT,
+	c_array_string ARRAY<STRING>
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO group_array_union_test VALUES
+	(1, ['a', 'b', 'c', 'd', 'e']),
+	(2, ['a', 'b']),
+	(3, ['a', null]),
+	(4, NULL);
+```
+
+```sql
+select GROUP_ARRAY_UNION(c_array_string) from group_array_union_test;
+```
+
+```text
++-----------------------------------+
+| GROUP_ARRAY_UNION(c_array_string) |
++-----------------------------------+
+| [null, "c", "e", "b", "d", "a"]   |
++-----------------------------------+
+```
+
+```sql
+select GROUP_ARRAY_UNION(c_array_string) from group_array_union_test where id in (3,4);
+```
+
+```text
++-----------------------------------+
+| GROUP_ARRAY_UNION(c_array_string) |
++-----------------------------------+
+| [null, "a"]                       |
++-----------------------------------+
+```
+
+```sql
+select GROUP_ARRAY_UNION(c_array_string) from group_array_union_test where id in (4);
+```
+
+```text
++-----------------------------------+
+| GROUP_ARRAY_UNION(c_array_string) |
++-----------------------------------+
+| []                                |
++-----------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-and.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-and.md
new file mode 100644
index 00000000000..9bf0c753a51
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-and.md
@@ -0,0 +1,68 @@
+---
+{
+    "title": "GROUP_BIT_AND",
+    "language": "ko",
+    "description": "단일 정수 컬럼 또는 표현식의 모든 값에 대해 비트 AND 연산을 수행합니다."
+}
+---
+
+## 설명 {#description}
+
+단일 정수 컬럼 또는 표현식의 모든 값에 대해 비트 AND 연산을 수행합니다.
+
+## 구문 {#syntax}
+
+```sql
+GROUP_BIT_AND(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 지원하는 타입: TinyInt, SmallInt, Integer, BigInt, LargeInt. |
+
+## 반환 값 {#return-value}
+
+<expr>와 동일한 타입의 정수 값을 반환합니다. 모든 값이 NULL이면 NULL을 반환합니다. NULL 값은 비트 연산에 포함되지 않습니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table group_bit(
+    value int
+) distributed by hash(value) buckets 1
+properties ("replication_num"="1");
+
+insert into group_bit values
+    (3),
+    (1),
+    (2),
+    (4),
+    (NULL);
+```
+
+```sql
+select group_bit_and(value) from group_bit;
+```
+
+```text
++----------------------+
+| group_bit_and(value) |
++----------------------+
+|                    0 |
++----------------------+
+```
+
+```sql
+select group_bit_and(value) from group_bit where value is null;
+```
+
+```text
++----------------------+
+| group_bit_and(value) |
++----------------------+
+|                 NULL |
++----------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-or.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-or.md
new file mode 100644
index 00000000000..30d17a22840
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-or.md
@@ -0,0 +1,68 @@
+---
+{
+    "title": "GROUP_BIT_OR",
+    "language": "ko",
+    "description": "단일 정수 열 또는 표현식의 모든 값에 대해 비트 OR 연산을 수행합니다."
+}
+---
+
+## 설명 {#description}
+
+단일 정수 열 또는 표현식의 모든 값에 대해 비트 OR 연산을 수행합니다.
+
+## 구문 {#syntax}
+
+```sql
+GROUP_BIT_OR(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 지원하는 타입: TinyInt, SmallInt, Integer, BigInt, LargeInt. |
+
+## 반환 값 {#return-value}
+
+<expr>와 동일한 타입의 정수 값을 반환합니다. 모든 값이 NULL이면 NULL을 반환합니다. NULL 값은 비트 연산에 포함되지 않습니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table group_bit(
+    value int
+) distributed by hash(value) buckets 1
+properties ("replication_num"="1");
+
+insert into group_bit values
+    (3),
+    (1),
+    (2),
+    (4),
+    (NULL);
+```
+
+```sql
+select group_bit_or(value) from group_bit;
+```
+
+```text
++---------------------+
+| group_bit_or(value) |
++---------------------+
+|                   7 |
++---------------------+
+```
+
+```sql
+select group_bit_or(value) from group_bit where value is null;
+```
+
+```text
++---------------------+
+| group_bit_or(value) |
++---------------------+
+|                NULL |
++---------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-xor.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-xor.md
new file mode 100644
index 00000000000..17c1658f43f
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bit-xor.md
@@ -0,0 +1,68 @@
+---
+{
+    "title": "GROUP_BIT_XOR",
+    "language": "ko",
+    "description": "단일 정수 열 또는 표현식의 모든 값에 대해 비트 XOR 연산을 수행합니다."
+}
+---
+
+## 설명 {#description}
+
+단일 정수 열 또는 표현식의 모든 값에 대해 비트 XOR 연산을 수행합니다.
+
+## 구문 {#syntax}
+
+```sql
+GROUP_BIT_XOR(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 지원하는 타입: TinyInt, SmallInt, Integer, BigInt, LargeInt. |
+
+## 반환 값 {#return-value}
+
+<expr>와 동일한 타입의 정수 값을 반환합니다. 모든 값이 NULL이면 NULL을 반환합니다. NULL 값은 비트 연산에서 제외됩니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table group_bit(
+    value int
+) distributed by hash(value) buckets 1
+properties ("replication_num"="1");
+
+insert into group_bit values
+    (3),
+    (1),
+    (2),
+    (4),
+    (NULL);
+```
+
+```sql
+select group_bit_xor(value) from group_bit;
+```
+
+```text
++----------------------+
+| group_bit_xor(value) |
++----------------------+
+|                    4 |
++----------------------+
+```
+
+```sql
+select group_bit_xor(value) from group_bit where value is null;
+```
+
+```text
++----------------------+
+| group_bit_xor(value) |
++----------------------+
+|                 NULL |
++----------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bitmap-xor.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bitmap-xor.md
new file mode 100644
index 00000000000..6f16d87ff02
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-bitmap-xor.md
@@ -0,0 +1,72 @@
+---
+{
+    "title": "GROUP_BITMAP_XOR",
+    "language": "ko",
+    "description": "주로 여러 bitmap의 값을 병합하고 그 결과에 대해 비트 단위 xor 연산을 수행하는 데 사용됩니다."
+}
+---
+
+## 설명 {#description}
+
+주로 여러 bitmap의 값을 병합하고 그 결과에 대해 비트 단위 xor 연산을 수행하는 데 사용됩니다.
+
+## 구문 {#syntax}
+
+```sql
+GROUP_BITMAP_XOR(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 지원되는 bitmap 데이터 타입 |
+
+## 반환 값 {#return-value}
+
+반환 값의 데이터 타입은 BITMAP입니다. 그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE pv_bitmap (
+	page varchar(10),
+	user_id BITMAP
+) DISTRIBUTED BY HASH(page) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO pv_bitmap VALUES
+	('m', to_bitmap(4)),
+	('m', to_bitmap(7)),
+	('m', to_bitmap(8)),
+	('m', to_bitmap(1)),
+	('m', to_bitmap(3)),
+	('m', to_bitmap(6)),
+	('m', to_bitmap(15)),
+	('m', to_bitmap(4)),
+	('m', to_bitmap(7));
+```
+
+```sql
+select page, bitmap_to_string(group_bitmap_xor(user_id)) from pv_bitmap group by page;
+```
+
+```text
++------+---------------------------------------------+
+| page | bitmap_to_string(group_bitmap_xor(user_id)) |
++------+---------------------------------------------+
+| m    | 1,3,6,8,15                                  |
++------+---------------------------------------------+
+```
+
+```sql
+select bitmap_to_string(group_bitmap_xor(user_id)) from pv_bitmap where page is null;
+```
+
+```text
++---------------------------------------------+
+| bitmap_to_string(group_bitmap_xor(user_id)) |
++---------------------------------------------+
+| NULL                                        |
++---------------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-concat.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-concat.md
new file mode 100644
index 00000000000..217a8056213
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/group-concat.md
@@ -0,0 +1,119 @@
+---
+{
+    "title": "GROUP_CONCAT",
+    "language": "ko",
+    "description": "GROUPCONCAT 함수는 결과 집합의 여러 행을 하나의 문자열로 연결합니다."
+}
+---
+
+## 설명 {#description}
+
+GROUP_CONCAT 함수는 결과 집합의 여러 행을 하나의 문자열로 연결합니다.
+
+## 구문 {#syntax}
+
+```sql
+GROUP_CONCAT([DISTINCT] <str>[, <sep>] [ORDER BY { <col_name> | <expr>} [ASC | DESC]])
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| ------------ | ---------------------- |
+| `<str>`      | 필수. 연결할 값을 나타내는 표현식입니다. |
+| `<sep>`      | 선택 사항. 문자열 사이의 구분자입니다. |
+| `<col_name>` | 선택 사항. 정렬에 사용할 열입니다.   |
+| `<expr>`     | 선택 사항. 정렬에 사용할 표현식입니다. |
+
+## 반환 값 {#return-value}
+
+VARCHAR 타입의 값을 반환합니다.
+입력 데이터에 NULL이 포함되어 있으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table test(
+    value varchar(10)
+) distributed by hash(value) buckets 1
+properties ("replication_num"="1");
+
+insert into test values
+    ("a"),
+    ("b"),
+    ("c"),
+    ("c");
+```
+
+```sql
+select GROUP_CONCAT(value) from test;
+```
+
+```text
++-----------------------+
+| GROUP_CONCAT(`value`) |
++-----------------------+
+| a, b, c, c            |
++-----------------------+
+```
+
+```sql
+select GROUP_CONCAT(DISTINCT value) from test;
+```
+
+```text
++-----------------------+
+| GROUP_CONCAT(`value`) |
++-----------------------+
+| a, b, c               |
++-----------------------+
+```
+
+```sql
+select GROUP_CONCAT(value ORDER BY value DESC) from test;
+```
+
+```text
++-----------------------+
+| GROUP_CONCAT(`value`) |
++-----------------------+
+| c, c, b, a            |
++-----------------------+
+```
+
+```sql
+select GROUP_CONCAT(DISTINCT value ORDER BY value DESC) from test;
+```
+
+```text
++-----------------------+
+| GROUP_CONCAT(`value`) |
++-----------------------+
+| c, b, a               |
++-----------------------+
+```
+
+```sql
+select GROUP_CONCAT(value, " ") from test;
+```
+
+```text
++----------------------------+
+| GROUP_CONCAT(`value`, ' ') |
++----------------------------+
+| a b c c                    |
++----------------------------+
+```
+
+```sql
+select GROUP_CONCAT(value, NULL) from test;
+```
+
+```text
++----------------------------+
+| GROUP_CONCAT(`value`, NULL)|
++----------------------------+
+| NULL                       |
++----------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/histogram.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/histogram.md
new file mode 100644
index 00000000000..e9e1d96da0a
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/histogram.md
@@ -0,0 +1,136 @@
+---
+{
+    "title": "HISTOGRAM",
+    "language": "ko",
+    "description": "histogram 함수는 데이터의 분포를 설명하는 데 사용되며, \"동일 높이\" 버킷 분할 전략을 사용합니다."
+}
+---
+
+## 설명 {#description}
+
+histogram 함수는 데이터의 분포를 설명하는 데 사용됩니다. "동일 높이" 버킷 분할 전략을 사용하여 데이터 값에 따라 데이터를 버킷으로 나눕니다. 각 버킷에 속하는 값의 개수와 같은 간단한 정보로 각 버킷을 설명합니다. NULL이 아닌 데이터만 집계합니다.
+
+## 별칭 {#alias}
+
+HIST
+
+## 구문 {#syntax}
+
+```sql
+HISTOGRAM(<expr>[, <num_buckets>])
+HIST(<expr>[, <num_buckets>])
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `expr` | 계산할 표현식입니다. 지원되는 타입: TinyInt, SmallInt, Integer, BigInt, LargeInt, Float, Double, Decimal, String. |
+| `num_buckets` | 선택 사항입니다. 히스토그램의 버킷 수를 제한합니다. 기본값은 128입니다. 지원되는 타입: Integer.|
+
+
+## 반환 값 {#return-value}
+
+히스토그램 추정 후 JSON 타입의 값을 반환합니다. 그룹의 모든 데이터가 NULL이면 NULL을 반환합니다. 유효한 데이터가 없으면 num_buckets = 0인 결과를 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE histogram_test (
+    c_int INT,
+    c_float FLOAT,
+    c_string VARCHAR(20)
+) DISTRIBUTED BY HASH(c_int) BUCKETS 1
+PROPERTIES ("replication_num"="1");
+
+INSERT INTO histogram_test VALUES
+    (1, 0.1, 'str1'),
+    (2, 0.2, 'str2'),
+    (3, 0.8, 'str3'),
+    (4, 0.9, 'str4'),
+    (5, 1.0, 'str5'),
+    (6, 1.0, 'str6'),
+    (NULL, NULL, 'str7');
+```
+
+```sql
+SELECT histogram(c_float) FROM histogram_test;
+```
+
+```text
++-------------------------------------------------------------------------------------------------------------------------------------+
+| histogram(c_float)                                                                                                                  |
++-------------------------------------------------------------------------------------------------------------------------------------+
+| {"num_buckets":5,"buckets":[{"lower":"0.1","upper":"0.1","ndv":1,"count":1,"pre_sum":0},{"lower":"0.2","upper":"0.2","ndv":1,"count":1,"pre_sum":1},{"lower":"0.8","upper":"0.8","ndv":1,"count":1,"pre_sum":2},{"lower":"0.9","upper":"0.9","ndv":1,"count":1,"pre_sum":3},{"lower":"1","upper":"1","ndv":1,"count":2,"pre_sum":4}]} |
++-------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+SELECT histogram(c_string, 2) FROM histogram_test;
+```
+
+```text
++-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+| histogram(c_string, 2)                                                                                                                                    |
++-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"num_buckets":2,"buckets":[{"lower":"str1","upper":"str4","ndv":4,"count":4,"pre_sum":0},{"lower":"str5","upper":"str7","ndv":3,"count":3,"pre_sum":4}]} |
++-----------------------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+-- NULL case
+SELECT histogram(c_float) FROM histogram_test WHERE c_float IS NULL;
+```
+
+```text
++--------------------------------+
+| histogram(c_float)             |
++--------------------------------+
+| {"num_buckets":0,"buckets":[]} |
++--------------------------------+
+```
+
+쿼리 결과 설명:
+
+```json
+{
+    "num_buckets": 3, 
+    "buckets": [
+        {
+            "lower": "0.1", 
+            "upper": "0.2", 
+            "count": 2, 
+            "pre_sum": 0, 
+            "ndv": 2
+        }, 
+        {
+            "lower": "0.8", 
+            "upper": "0.9", 
+            "count": 2, 
+            "pre_sum": 2, 
+            "ndv": 2
+        }, 
+        {
+            "lower": "1.0", 
+            "upper": "1.0", 
+            "count": 2, 
+            "pre_sum": 4, 
+            "ndv": 1
+        }
+    ]
+}
+```
+
+```text
+Field description:
+- num_buckets: The number of buckets
+- buckets: All buckets
+    - lower: Lower bound of the bucket
+    - upper: Upper bound of the bucket
+    - count: The number of elements contained in the bucket
+    - pre_sum: The total number of elements in the front bucket
+    - ndv: The number of different values in the bucket
+
+> Total number of elements in the histogram = count of the last bucket + pre_sum of the last bucket.
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/hll-raw-agg.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/hll-raw-agg.md
new file mode 100644
index 00000000000..13c334a6dfb
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/hll-raw-agg.md
@@ -0,0 +1,74 @@
+---
+{
+    "title": "HLL_RAW_AGG",
+    "language": "ko",
+    "description": "HLLRAWAGG 함수는 여러 HyperLogLog 데이터 구조를 하나로 병합하는 데 주로 사용되는 집계 함수입니다."
+}
+---
+
+## 설명 {#description}
+
+HLL_RAW_AGG 함수는 여러 HyperLogLog 데이터 구조를 하나로 병합하는 데 주로 사용되는 집계 함수입니다.
+
+## 별칭 {#alias}
+
+- HLL_UNION
+
+## 구문 {#syntax}
+
+```sql
+HLL_RAW_AGG(<hll>)
+HLL_UNION(<hll>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<hll>` | 계산할 표현식으로, HLL 타입을 지원합니다. |
+
+## 반환 값 {#return-value}
+
+집계된 HLL 타입을 반환합니다.
+그룹에 유효한 데이터가 없으면 HLL_EMPTY를 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table test_uv(
+    id int,
+    uv_set string
+) distributed by hash(id) buckets 1
+properties ("replication_num"="1");
+insert into test_uv values
+    (1, ('a')),
+    (1, ('b')),
+    (2, ('c')),
+    (2, ('d')),
+    (3, null);
+```
+
+```sql
+select HLL_CARDINALITY(HLL_RAW_AGG(hll_hash(uv_set))) from test_uv;
+```
+
+```text
++------------------------------------------------+
+| HLL_CARDINALITY(HLL_RAW_AGG(hll_hash(uv_set))) |
++------------------------------------------------+
+|                                              4 |
++------------------------------------------------+
+```
+
+```sql
+select HLL_CARDINALITY(HLL_RAW_AGG(hll_hash(uv_set))) from test_uv where uv_set is null;
+```
+
+```text
++------------------------------------------------+
+| HLL_CARDINALITY(HLL_RAW_AGG(hll_hash(uv_set))) |
++------------------------------------------------+
+|                                              0 |
++------------------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/hll-union-agg.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/hll-union-agg.md
new file mode 100644
index 00000000000..20eec1245b9
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/hll-union-agg.md
@@ -0,0 +1,69 @@
+---
+{
+    "title": "HLL_UNION_AGG",
+    "language": "ko",
+    "description": "HLLUNIONAGG 함수는 주로 여러 HyperLogLog 데이터 구조를 병합하고 근사 카디널리티를 추정하는 데 사용되는 집계 함수입니다. "
+}
+---
+
+## 설명 {#description}
+
+HLL_UNION_AGG 함수는 주로 여러 HyperLogLog 데이터 구조를 병합하고 병합 후의 근사 카디널리티를 추정하는 데 사용되는 집계 함수입니다.
+
+## 구문 {#syntax}
+
+```sql
+hll_union_agg(<hll>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<hll>` | 계산할 표현식으로, HLL 타입을 지원합니다. |
+
+## 반환 값 {#return-value}
+
+BIGINT 타입의 카디널리티 값을 반환합니다.
+그룹에 유효한 데이터가 없으면 0을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table test_uv(
+    id int,
+    uv_set string
+) distributed by hash(id) buckets 1
+properties ("replication_num"="1");
+insert into test_uv values
+    (1, ('a')),
+    (1, ('b')),
+    (2, ('c')),
+    (2, ('d')),
+    (3, null);
+```
+
+```sql
+select HLL_UNION_AGG(HLL_HASH(uv_set)) from test_uv;
+```
+
+```text
++---------------------------------+
+| HLL_UNION_AGG(HLL_HASH(uv_set)) |
++---------------------------------+
+|                               4 |
++---------------------------------+
+```
+
+```sql
+select HLL_UNION_AGG(HLL_HASH(uv_set)) from test_uv where uv_set is null;
+```
+
+```text
++---------------------------------+
+| HLL_UNION_AGG(HLL_HASH(uv_set)) |
++---------------------------------+
+|                               0 |
++---------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/intersect-count.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/intersect-count.md
new file mode 100644
index 00000000000..ef870f7537e
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/intersect-count.md
@@ -0,0 +1,78 @@
+---
+{
+    "title": "INTERSECT_COUNT",
+    "language": "ko",
+    "description": "둘 이상의 bitmap의 교집합을 계산합니다. 사용법: intersectcount(bitmapcolumntocount, filtercolumn, filtervalues ..."
+}
+---
+
+## 설명 {#description}
+
+둘 이상의 bitmap의 교집합을 계산합니다.
+사용법: intersect_count(bitmap_column_to_count, filter_column, filter_values ...)
+예: intersect_count(user_id, event, 'A', 'B', 'C')는 A/B/C 3개 bitmap 모두에 포함된 user_id의 개수를 구한다는 의미입니다.
+bitmap_column의 원소 중 column_to_filter가 filter_values 내의 값과 일치하는 원소의 교집합 원소 수, 즉 bitmap 교집합의 원소 수를 계산합니다.
+
+## 구문 {#syntax}
+
+```sql
+INTERSECT_COUNT(<bitmap_column>, <column_to_filter>, <filter_values> [, ...])
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수         | 설명                                      |
+|------------------|--------------------------------------------------|
+| `<bitmap_column>`  | 입력 bitmap 매개변수 컬럼입니다. 지원 타입: Bitmap. |
+| `<column_to_filter>` | 필터링에 사용하는 차원 컬럼입니다. 지원 타입: TinyInt, SmallInt, Integer, BigInt, LargeInt. |
+| `<filter_values>`  | 차원 컬럼을 필터링하는 데 사용하는 서로 다른 값입니다. 지원 타입: TinyInt, SmallInt, Integer, BigInt, LargeInt. |
+
+
+## 반환 값 {#return-value}
+
+주어진 bitmap들의 교집합에 포함된 원소 수를 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE pv_bitmap (
+	dt INT,
+	user_id BITMAP,
+	city STRING
+) DISTRIBUTED BY HASH(dt) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO pv_bitmap VALUES
+	(20250801, to_bitmap(1), 'beijing'),
+	(20250801, to_bitmap(2), 'beijing'),
+	(20250801, to_bitmap(3), 'shanghai'),
+	(20250802, to_bitmap(3), 'beijing'),
+	(20250802, to_bitmap(4), 'shanghai'),
+	(20250802, to_bitmap(5), 'shenzhen');
+```
+
+```sql
+select intersect_count(user_id,dt,20250801) from pv_bitmap;
+```
+
+```text
++--------------------------------------+
+| intersect_count(user_id,dt,20250801) |
++--------------------------------------+
+|                                    3 |
++--------------------------------------+
+```
+
+두 날짜의 교집합을 구하여 `20250801`과 `20250802`에 모두 존재하는 사용자의 수를 계산합니다(두 날짜에 모두 나타나는 사용자는 `user_id`가 3인 사용자뿐입니다):
+
+```sql
+select intersect_count(user_id,dt,20250801,20250802) from pv_bitmap;
+```
+
+```text
++-----------------------------------------------+
+| intersect_count(user_id,dt,20250801,20250802) |
++-----------------------------------------------+
+|                                             1 |
++-----------------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/kurt.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/kurt.md
new file mode 100644
index 00000000000..8209170b8cd
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/kurt.md
@@ -0,0 +1,81 @@
+---
+{
+    "title": "KURT,KURT_POP,KURTOSIS",
+    "language": "ko",
+    "description": "KURTOSIS 함수는 데이터의 첨도를 계산합니다. 계산 공식은 사차 중심 모멘트 / (분산의 제곱) - 3입니다."
+}
+---
+
+## 설명 {#description}
+
+KURTOSIS 함수는 데이터의 [첨도](https://en.wikipedia.org/wiki/Kurtosis)를 계산합니다. 계산 공식은 사차 중심 모멘트 / (분산의 제곱) - 3입니다.
+
+## 별칭 {#alias}
+
+KURT_POP, KURTOSIS
+
+## 구문 {#syntax}
+
+```sql
+KURTOSIS(<expr>)
+KURT_POP(<expr>)
+KURT(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 계산할 표현식입니다. Double 타입을 지원합니다. |
+
+## 반환 값 {#return-value}
+
+DOUBLE 값을 반환합니다.
+분산이 영이면 NULL을 반환합니다.
+그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table statistic_test(
+    tag int,
+    val1 double,
+    val2 double
+) distributed by hash(tag) buckets 1
+properties ("replication_num"="1");
+insert into statistic_test values
+    (1, -10, -10),
+    (2, -20, null),
+    (3, 100, null),
+    (4, 100, null),
+    (5, 1000, 1000);
+```
+
+```sql
+select kurt(val1), kurt(val2) from statistic_test;
+```
+
+```text
++---------------------+------------+
+| kurt(val1)          | kurt(val2) |
++---------------------+------------+
+| 0.16212458373485106 |         -2 |
++---------------------+------------+
+```
+
+```sql
+select kurt(val1), kurt(val2) from statistic_test group by tag;
+```
+
+```text
++------------+------------+
+| kurt(val1) | kurt(val2) |
++------------+------------+
+|       NULL |       NULL |
+|       NULL |       NULL |
+|       NULL |       NULL |
+|       NULL |       NULL |
+|       NULL |       NULL |
++------------+------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/linear-histogram.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/linear-histogram.md
new file mode 100644
index 00000000000..dd26c3cac50
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/linear-histogram.md
@@ -0,0 +1,96 @@
+---
+{
+    "title": "LINEAR_HISTOGRAM",
+    "language": "ko",
+    "description": "LINEARHISTOGRAM 함수는 데이터 분포를 나타내는 데 사용됩니다."
+}
+---
+
+## 설명 {#description}
+
+LINEAR_HISTOGRAM 함수는 데이터 분포를 나타내는 데 사용됩니다. "동일 너비" 버킷 분할 전략을 사용하여 값의 크기에 따라 데이터를 버킷으로 나눕니다.
+
+## 구문 {#syntax}
+
+```sql
+LINEAR_HISTOGRAM(<expr>, <interval> [, <offset>])
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 요약할 표현식입니다. BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE, DECIMAL을 지원합니다. Doris 4.1 시리즈에서는 4.1.5부터 BOOLEAN 입력을 지원하며, FALSE와 TRUE는 각각 0과 1로 집계됩니다. |
+| `<interval>` | DOUBLE 타입의 버킷 너비입니다. 0보다 커야 합니다. |
+| `<offset>` | 선택 사항인 DOUBLE 타입의 오프셋입니다. 기본값은 0이며, `[0, interval)` 범위에 있어야 합니다. |
+
+## 반환 값 {#return-value}
+
+버킷 경계, 개수 및 누적 개수를 나타내는 JSON 텍스트를 VARCHAR로 반환합니다. NULL 입력은 무시됩니다. 모든 입력이 NULL이거나 입력 행이 없으면 `{"num_buckets":0,"buckets":[]}`를 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table histogram_test(
+  a int
+) distributed by hash(a) buckets 1
+properties ("replication_num"="1");
+insert into histogram_test values
+  (0), (1), (2), (3), (4), (5), (6), (7), (8), (9), (10), (11), (null);
+```
+
+```sql
+select linear_histogram(a, 2) from histogram_test;
+```
+
+```text
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| linear_histogram(a, 2)                                                                                                                                                                                                                                                                                                                         |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"num_buckets":6,"buckets":[{"lower":0.0,"upper":2.0,"count":2,"acc_count":2},{"lower":2.0,"upper":4.0,"count":2,"acc_count":4},{"lower":4.0,"upper":6.0,"count":2,"acc_count":6},{"lower":6.0,"upper":8.0,"count":2,"acc_count":8},{"lower":8.0,"upper":10.0,"count":2,"acc_count":10},{"lower":10.0,"upper":12.0,"count":2,"acc_count":12}]} |
++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+select linear_histogram(a, 2, 1) from histogram_test;
+```
+
+```text
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| linear_histogram(a, 2, 1)                                                                                                                                                                                                                                                                                                                                                                         |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| {"num_buckets":7,"buckets":[{"lower":-1.0,"upper":1.0,"count":1,"acc_count":1},{"lower":1.0,"upper":3.0,"count":2,"acc_count":3},{"lower":3.0,"upper":5.0,"count":2,"acc_count":5},{"lower":5.0,"upper":7.0,"count":2,"acc_count":7},{"lower":7.0,"upper":9.0,"count":2,"acc_count":9},{"lower":9.0,"upper":11.0,"count":2,"acc_count":11},{"lower":11.0,"upper":13.0,"count":1,"acc_count":12}]} |
++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+```sql
+select linear_histogram(a, 2, 1) from histogram_test where a is null;
+```
+
+```text
++--------------------------------+
+| linear_histogram(a, 2, 1)      |
++--------------------------------+
+| {"num_buckets":0,"buckets":[]} |
+```
+
+필드 설명:
+
+- `num_buckets`: 버킷 수입니다.
+- `buckets`: 히스토그램의 버킷입니다.
+  - `lower`: 하한값입니다(포함).
+  - `upper`: 상한값입니다(미포함).
+  - `count`: 버킷에 속한 요소의 개수입니다.
+  - `acc_count`: 이 버킷까지의 누적 개수입니다.
+
+BOOLEAN 입력에는 0과 1에 해당하는 버킷이 사용되며, NULL은 개수에 포함되지 않습니다:
+
+```sql
+SELECT LINEAR_HISTOGRAM(b, 1.0)
+FROM (SELECT TRUE AS b UNION ALL SELECT FALSE UNION ALL SELECT TRUE UNION ALL SELECT NULL) t;
+```
+
+```text
+{"num_buckets":2,"buckets":[{"lower":0.0,"upper":1.0,"count":1,"acc_count":1},{"lower":1.0,"upper":2.0,"count":2,"acc_count":3}]}
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/map-agg.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/map-agg.md
new file mode 100644
index 00000000000..5e8e91a75cd
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/map-agg.md
@@ -0,0 +1,105 @@
+---
+{
+    "title": "MAP_AGG",
+    "language": "ko",
+    "description": "MAPAGG 함수는 여러 데이터 행의 키-값 쌍을 바탕으로 매핑 구조를 구성하는 데 사용됩니다."
+}
+---
+
+## 설명 {#description}
+
+MAP_AGG 함수는 여러 데이터 행의 키-값 쌍을 바탕으로 매핑 구조를 구성하는 데 사용됩니다.
+
+중복 키가 있는 경우, `MAP_AGG`는 집계 중 처음 처리한 값을 유지하고 이미 존재하는 키의 후속 값은 무시합니다. 부분 집계 상태를 병합할 때도 대상 상태에 이미 있는 값을 유지합니다.
+
+“처음 처리한 값”에서 “처음”은 삽입 순서가 아니라 처리 순서를 의미합니다. 스캔, 병렬 실행, 부분 상태의 병합 순서에 따라 유지되는 값이 달라질 수 있으므로, 중복 키에 대해 선택되는 값이 쿼리마다 동일하다고 보장되지 않습니다. 외부 `ORDER BY`는 결과 행만 정렬하며, 중복 키에 대해 어떤 값을 유지할지는 결정하지 않습니다.
+
+## 구문 {#syntax}
+
+```sql
+MAP_AGG(<expr1>, <expr2>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr1>` | 키로 사용되는 표현식입니다. 지원되는 타입: Bool, TinyInt, SmallInt, Integer, BigInt, LargeInt, Float, Double, Decimal, Date, Datetime, String. |
+| `<expr2>` | 값으로 사용되는 표현식입니다. 지원되는 타입: Bool, TinyInt, SmallInt, Integer, BigInt, LargeInt, Float, Double, Decimal, Date, Datetime, String. |
+
+## 반환 값 {#return-value}
+
+Map 타입의 값을 반환합니다. 그룹에 유효한 데이터가 없으면 빈 Map을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE nation (
+    n_nationkey INT,
+    n_name STRING,
+    n_regionkey INT
+) DISTRIBUTED BY HASH(n_nationkey) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+INSERT INTO nation VALUES
+    (0, 'ALGERIA', 0),
+    (1, 'ARGENTINA', 1),
+    (2, 'BRAZIL', 1),
+    (3, 'CANADA', 1);
+```
+
+```sql
+select `n_regionkey`, map_agg(`n_nationkey`, `n_name`) from `nation` group by `n_regionkey`;
+```
+
+```text
++-------------+-----------------------------------------+
+| n_regionkey | map_agg(`n_nationkey`, `n_name`)        |
++-------------+-----------------------------------------+
+|           0 | {0:"ALGERIA"}                           |
+|           1 | {1:"ARGENTINA", 2:"BRAZIL", 3:"CANADA"} |
++-------------+-----------------------------------------+
+```
+
+```sql
+select map_agg(`n_name`, `n_nationkey` % 5) from `nation`;
+```
+
+```text
++------------------------------------------------------+
+| map_agg(`n_name`, `n_nationkey` % 5)                 |
++------------------------------------------------------+
+| {"ALGERIA":0, "ARGENTINA":1, "BRAZIL":2, "CANADA":3} |
++------------------------------------------------------+
+```
+
+```sql
+select map_agg(`n_name`, `n_nationkey` % 5) from `nation` where n_nationkey is null;
+```
+
+```text
++--------------------------------------+
+| map_agg(`n_name`, `n_nationkey` % 5) |
++--------------------------------------+
+| {}                                   |
++--------------------------------------+
+```
+
+다음 쿼리에는 중복 키가 있으므로 결과에는 키-값 쌍이 하나만 포함됩니다. 어떤 값이 먼저 처리되는지에 따라 결과는 `{1:"a"}` 또는 `{1:"b"}`가 될 수 있습니다. 가능한 출력의 한 예는 다음과 같습니다.
+
+```sql
+SELECT MAP_AGG(k, v) AS result
+FROM (
+    SELECT 1 AS k, 'a' AS v
+    UNION ALL
+    SELECT 1 AS k, 'b' AS v
+) AS input;
+```
+
+```text
++---------+
+| result  |
++---------+
+| {1:"a"} |
++---------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max-by.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max-by.md
new file mode 100644
index 00000000000..31cabc27b76
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max-by.md
@@ -0,0 +1,127 @@
+---
+{
+    "title": "MAX_BY",
+    "language": "ko",
+    "description": "MAXBY 함수는 지정된 열의 최댓값에 대응하는 값을 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+MAX_BY 함수는 지정된 열의 최댓값에 대응하는 값을 반환합니다.
+
+`<expr2>`가 Array인 경우, 배열은 요소별로 사전식으로 비교되며 NULL 요소는 NULL이 아닌 모든 요소보다 큽니다. NULL 배열 값은 무시됩니다.
+
+버전별 차이: Doris 4.1 계열의 4.1.5 이상 버전과 Doris 4.2 이상에서는 배열 내부의 `NULL` 요소를 `NULL`이 아닌 요소보다 큰 값으로 비교합니다. Doris 4.0과 Doris 4.1의 4.1.5 이전 버전에서는 `NULL` 배열 요소를 더 작은 값으로 비교합니다. 이 모든 버전에서 `NULL` 배열 값은 무시됩니다.
+
+## 구문 {#syntax}
+
+```sql
+MAX_BY(<expr1>, <expr2>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| --- | --- |
+| `<expr1>` | 대응하는 값의 표현식입니다. 지원하는 타입: Bool, TinyInt, SmallInt, Int, BigInt, LargeInt, Float, Double, Decimal, String, Date, Datetime, Array, Map, Struct. |
+| `<expr2>` | 최댓값을 구할 표현식입니다. 지원하는 타입: Bool, TinyInt, SmallInt, Int, BigInt, LargeInt, Float, Double, Decimal, String, Date, Datetime, Array. |
+
+## 반환 값 {#return-value}
+
+<expr1>과 동일한 데이터 타입을 반환합니다.
+그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table tbl(
+    k1 int,
+    k2 int,
+    arr ARRAY<INT>,
+    mp MAP<STRING, INT>,
+    st STRUCT<a: INT, b: STRING>,
+) distributed by hash(k1) buckets 1
+properties ("replication_num"="1");
+insert into tbl values
+    (0, 100, [1,2,3], {"x": 1, "y": 4}, NAMED_STRUCT("a", 1, "b", "x")),
+    (1, 4,   [5, 6],  {"x": 2, "y": 3}, NAMED_STRUCT("a", 2, "b", "y")),
+    (4, 1,   [7],     {"x": 3, "y": 2}, NAMED_STRUCT("a", 3, "b", "z")),
+    (3, 1,   [8],     {"x": 4, "y": 1}, NAMED_STRUCT("a", 4, "b", "r"));
+```
+
+```text
+Table created and data inserted successfully.
+```
+
+```sql
+select max_by(k1, k2) from tbl;
+```
+
+```text
++----------------+
+| max_by(k1, k2) |
++----------------+
+|              0 |
++----------------+
+```
+
+```sql
+select max_by(arr, k1), max_by(mp, k1), max_by(st, k1) from tbl;
+```
+
+```text
++-----------------+----------------+------------------+
+| max_by(arr, k1) | max_by(mp, k1) | max_by(st, k1)   |
++-----------------+----------------+------------------+
+| [7]             | {"x":3, "y":2} | {"a":3, "b":"z"} |
++-----------------+----------------+------------------+
+```
+
+```sql
+select max_by(k1, arr), max_by(mp, arr), max_by(st, arr), max_by(arr, arr) from tbl;
+```
+
+```text
++-----------------+-----------------+------------------+------------------+
+| max_by(k1, arr) | max_by(mp, arr) | max_by(st, arr)  | max_by(arr, arr) |
++-----------------+-----------------+------------------+------------------+
+|               3 | {"x":4, "y":1}  | {"a":4, "b":"r"} | [8]              |
++-----------------+-----------------+------------------+------------------+
+```
+
+```sql
+select max_by(k1, k2) from tbl where k1 is null;
+```
+
+```text
++----------------+
+| max_by(k1, k2) |
++----------------+
+|           NULL |
++----------------+
+```
+
+다음 배열 비교 예제는 Doris 4.1 계열의 4.1.5 이상 버전과 Doris 4.2 이상에 적용됩니다.
+
+```sql
+SELECT max_by(label, sort_key) AS result
+FROM (
+    SELECT 'null element' AS label, [1, NULL] AS sort_key
+    UNION ALL SELECT 'non-null element', [1, 2]
+    UNION ALL SELECT 'null array', CAST(NULL AS ARRAY<INT>)
+) t;
+```
+
+```text
+null element
+```
+
+```sql
+SELECT max_by(1, CAST(NULL AS ARRAY<INT>)) AS result;
+```
+
+```text
+NULL
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max-map.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max-map.md
new file mode 100644
index 00000000000..a05eda0d22f
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max-map.md
@@ -0,0 +1,115 @@
+---
+{
+    "title": "MAX_MAP",
+    "language": "ko",
+    "description": "MAX_MAP 함수는 MAP 값을 키별로 집계하고 각 키의 최댓값을 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+MAX_MAP 함수는 MAP 값을 키별로 집계하고 각 키의 NULL이 아닌 최댓값을 담은 MAP을 반환합니다.
+
+## 사용 시 참고 사항 {#usage-notes}
+
+반환되는 MAP의 항목 순서는 보장되지 않습니다. 일정한 출력 순서가 필요한 경우 `map_keys`, `map_values`, `array_sort`, `array_sortby`를 사용하세요. NULL 키는 일반 키와 동일하게 집계되며, 모든 NULL 키는 결과에서 하나의 항목으로 합쳐집니다.
+
+## 구문 {#syntax}
+
+```sql
+MAX_MAP(<map_expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| --- | --- |
+| `<map_expr>` | MAP 표현식입니다. MAP 값의 타입은 MAX 집계 함수로 비교할 수 있어야 합니다. |
+
+## 반환값 {#return-value}
+
+키 타입이 `<map_expr>`와 같은 MAP을 반환합니다. 값 타입이 DecimalV2이면 반환되는 값 타입은 이에 대응하는 DecimalV3 타입입니다. 그 외에는 반환되는 값 타입이 입력 MAP의 값 타입과 같습니다.
+
+그룹에 유효한 입력 행이 없으면 빈 MAP을 반환합니다. 특정 키가 존재하지만 해당 키의 값이 모두 NULL이면 해당 키의 값은 NULL입니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE map_agg_example (
+    id INT,
+    m MAP<INT, INT>,
+    ms MAP<INT, STRING>
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO map_agg_example VALUES
+    (1, MAP(1, 10, 2, 20), MAP(1, 'b', 2, 'x')),
+    (1, MAP(2, 5, 3, 30), MAP(1, 'a', 3, NULL)),
+    (2, MAP(1, 7, 4, NULL), MAP(2, 'z')),
+    (2, CAST(MAP() AS MAP<INT, INT>), CAST(MAP() AS MAP<INT, STRING>));
+```
+
+```text
+Query OK
+```
+
+```sql
+SELECT id,
+       array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT id, MAX_MAP(m) AS result
+    FROM map_agg_example
+    GROUP BY id
+) t
+ORDER BY id;
+```
+
+```text
++------+-----------+--------------+
+| id   | keys      | values       |
++------+-----------+--------------+
+|    1 | [1, 2, 3] | [10, 20, 30] |
+|    2 | [1, 4]    | [7, null]    |
++------+-----------+--------------+
+```
+
+```sql
+SELECT id,
+       array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT id, MAX_MAP(ms) AS result
+    FROM map_agg_example
+    GROUP BY id
+) t
+ORDER BY id;
+```
+
+```text
++------+-----------+----------------+
+| id   | keys      | values         |
++------+-----------+----------------+
+|    1 | [1, 2, 3] | ["b", "x", null] |
+|    2 | [2]       | ["z"]          |
++------+-----------+----------------+
+```
+
+```sql
+SELECT array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT MAX_MAP(m) AS result
+    FROM map_agg_example
+    WHERE id = 100
+) t;
+```
+
+```text
++------+--------+
+| keys | values |
++------+--------+
+| []   | []     |
++------+--------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max.md
new file mode 100644
index 00000000000..acff7c95316
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/max.md
@@ -0,0 +1,136 @@
+---
+{
+    "title": "MAX",
+    "language": "ko",
+    "description": "MAX 함수는 표현식에서 NULL이 아닌 값 중 최댓값을 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+MAX 함수는 표현식에서 NULL이 아닌 값 중 최댓값을 반환합니다.
+
+버전별 차이: Doris 4.1 시리즈의 4.1.5부터, 그리고 Doris 4.2 이상 버전에서는 배열 내부의 `NULL` 요소를 `NULL`이 아닌 요소보다 큰 것으로 비교합니다. Doris 4.0 및 Doris 4.1의 4.1.5 이전 버전에서는 `NULL` 배열 요소를 더 작은 것으로 비교합니다. 이 모든 버전에서 배열 값 자체가 `NULL`인 경우에는 무시됩니다.
+
+## 구문 {#syntax}
+
+```sql
+MAX(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| --- | --- |
+| `<expr>` | 값을 구할 표현식입니다. 지원되는 타입은 String, Time, Date, DateTime, Timestamptz, IPv4, IPv6, TinyInt, SmallInt, Integer, BigInt, LargeInt, Float, Double, Decimal, Array입니다. |
+
+## 반환값 {#return-value}
+
+입력 표현식과 같은 데이터 타입을 반환합니다.
+그룹의 모든 레코드가 NULL이면 함수는 NULL을 반환합니다.
+
+
+:::caution 동작 변경 (4.1.5)
+
+Doris 4.1 시리즈에서는 4.1.5부터 배열과 같은 복합 값 내부의 NULL 요소를 같은 위치의 NULL이 아닌 요소보다 큰 것으로 비교합니다. 예를 들어, `[10, 20, NULL]`은 `[10, 20, 40]`보다 큽니다. 이는 표현식 전체가 NULL인 경우와 다릅니다. 표현식 전체가 NULL인 행은 여전히 무시됩니다. 4.1.5 이전에는 집계 비교에서 복합 값 내부의 NULL 요소를 더 작은 것으로 처리했습니다.
+
+:::
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table t1(
+        k1 int,
+        k_string varchar(100),
+        k_decimal decimal(10, 2),
+        k_array array<int>
+) distributed by hash (k1) buckets 1
+properties ("replication_num"="1");
+insert into t1 values 
+    (1, 'apple', 10.01, [10, 20, 30]),
+    (1, 'banana', 20.02, [10, 20]),
+    (2, 'orange', 30.03, [10, 20, 40]),
+    (2, null, null, [10, 20, null]),
+    (3, null, null, null);
+```
+
+```text
+Table created and data inserted successfully.
+```
+
+```sql
+select k1, max(k_string) from t1 group by k1 order by k1;
+```
+
+String 타입: 각 그룹에서 가장 큰 문자열 값을 반환합니다.
+
+```text
++------+---------------+
+| k1   | max(k_string) |
++------+---------------+
+|    1 | banana        |
+|    2 | orange        |
+|    3 | NULL          |
++------+---------------+
+```
+
+```sql
+select k1, max(k_decimal) from t1 group by k1 order by k1;
+```
+
+Decimal 타입: 고정밀 십진수 값 중 최댓값을 반환합니다.
+
+```text
++------+----------------+
+| k1   | max(k_decimal) |
++------+----------------+
+|    1 |          20.02 |
+|    2 |          30.03 |
+|    3 |           NULL |
++------+----------------+
+```
+
+```sql
+select k1, max(k_array) from t1 group by k1 order by k1;
+```
+
+Array 타입: 요소를 순서대로 비교하고 각 그룹에서 가장 큰 배열 값을 반환합니다. 같은 위치의 요소를 비교할 때 NULL 요소는 NULL이 아닌 요소보다 큰 것으로 처리됩니다.
+
+```text
++------+----------------+
+| k1   | max(k_array)   |
++------+----------------+
+|    1 | [10, 20, 30]   |
+|    2 | [10, 20, null] |
+|    3 | NULL           |
++------+----------------+
+```
+
+```sql
+select max(k_string) from t1 where k1 = 3;
+```
+
+그룹의 모든 값이 NULL이면 NULL을 반환합니다.
+
+```text
++---------------+
+| max(k_string) |
++---------------+
+| NULL          |
++---------------+
+```
+
+```sql
+select max(k_string) from t1;
+```
+
+전체 데이터에서 최댓값을 반환합니다.
+
+```text
++---------------+
+| max(k_string) |
++---------------+
+| orange        |
++---------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/median.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/median.md
new file mode 100644
index 00000000000..da95bc31991
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/median.md
@@ -0,0 +1,73 @@
+---
+{
+    "title": "MEDIAN",
+    "language": "ko",
+    "description": "MEDIAN 함수는 표현식의 중앙값을 반환하며, percentile(expr, 0.5)와 동일합니다."
+}
+---
+
+## 설명 {#description}
+
+MEDIAN 함수는 표현식의 중앙값을 반환하며, percentile(expr, 0.5)와 동일합니다.
+
+## 구문 {#syntax}
+
+```sql
+MEDIAN(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<expr>` | 계산할 표현식입니다. 지원하는 타입은 Double, Float, LargeInt, BigInt, Int, SmallInt, TinyInt입니다. |
+
+## 반환값 {#return-value}
+
+입력 표현식과 동일한 데이터 타입을 반환합니다.
+그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table log_statis(
+    datetime datetime,
+    scan_rows int
+) distributed by hash(datetime) buckets 1
+properties ("replication_num"="1");
+insert into log_statis values
+    ('2025-08-25 10:00:00', 10),
+    ('2025-08-25 10:00:00', 50),
+    ('2025-08-25 10:00:00', 100),
+    ('2025-08-25 11:00:00', 20),
+    ('2025-08-25 11:00:00', 30),
+    ('2025-08-25 11:00:00', 40);
+```
+
+```sql
+select datetime, median(scan_rows) from log_statis group by datetime;
+```
+
+```text
+select datetime, median(scan_rows) from log_statis group by datetime;
++---------------------+-------------------+
+| datetime            | median(scan_rows) |
++---------------------+-------------------+
+| 2025-08-25 10:00:00 |                50 |
+| 2025-08-25 11:00:00 |                30 |
++---------------------+-------------------+
+```
+
+```sql
+select median(scan_rows) from log_statis where scan_rows is null;
+```
+
+```text
+select median(scan_rows) from log_statis where scan_rows is null;
++-------------------+
+| median(scan_rows) |
++-------------------+
+|              NULL |
++-------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min-by.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min-by.md
new file mode 100644
index 00000000000..229f4b94fb8
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min-by.md
@@ -0,0 +1,127 @@
+---
+{
+    "title": "MIN_BY",
+    "language": "ko",
+    "description": "MINBY 함수는 지정한 열의 최솟값에 대응하는 값을 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+MIN_BY 함수는 지정한 열의 최솟값에 대응하는 값을 반환합니다.
+
+`<expr2>`가 Array인 경우 배열을 요소별로 사전순으로 비교하며, NULL 요소는 NULL이 아닌 모든 요소보다 큰 것으로 간주합니다. NULL 배열 값은 무시합니다.
+
+버전별 차이: Doris 4.1 계열의 4.1.5 이상 버전과 Doris 4.2 이상에서는 배열 내부의 `NULL` 요소를 `NULL`이 아닌 요소보다 큰 것으로 간주합니다. Doris 4.0과 Doris 4.1의 4.1.5 이전 버전에서는 `NULL` 배열 요소를 더 작은 것으로 간주합니다. 이 모든 버전에서 `NULL` 배열 값은 무시합니다.
+
+## 구문 {#syntax}
+
+```sql
+MIN_BY(<expr1>, <expr2>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| --- | --- |
+| `<expr1>` | 대응하는 값에 대한 표현식입니다. 지원 타입: Bool, TinyInt, SmallInt, Int, BigInt, LargeInt, Float, Double, Decimal, String, Date, Datetime, Array, Map, Struct. |
+| `<expr2>` | 최솟값에 대한 표현식입니다. 지원 타입: Bool, TinyInt, SmallInt, Int, BigInt, LargeInt, Float, Double, Decimal, String, Date, Datetime, Array. |
+
+## 반환 값 {#return-value}
+
+<expr1>과 동일한 데이터 타입을 반환합니다.
+그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table tbl(
+    k1 int,
+    k2 int,
+    arr ARRAY<INT>,
+    mp MAP<STRING, INT>,
+    st STRUCT<a: INT, b: STRING>,
+) distributed by hash(k1) buckets 1
+properties ("replication_num"="1");
+insert into tbl values
+    (0, 100, [1,2,3], {"x": 1, "y": 4}, NAMED_STRUCT("a", 1, "b", "x")),
+    (1, 4,   [5, 6],  {"x": 2, "y": 3}, NAMED_STRUCT("a", 2, "b", "y")),
+    (4, 1,   [7],     {"x": 3, "y": 2}, NAMED_STRUCT("a", 3, "b", "z")),
+    (3, 1,   [8],     {"x": 4, "y": 1}, NAMED_STRUCT("a", 4, "b", "r"));
+```
+
+```text
+Table created and data inserted successfully.
+```
+
+```sql
+select min_by(k1, k2) from tbl;
+```
+
+```text
++----------------+
+| min_by(k1, k2) |
++----------------+
+|              3 |
++----------------+
+```
+
+```sql
+select min_by(arr, k1), min_by(mp, k1), min_by(st, k1) from tbl;
+```
+
+```text
++-----------------+----------------+------------------+
+| min_by(arr, k1) | min_by(mp, k1) | min_by(st, k1)   |
++-----------------+----------------+------------------+
+| [1, 2, 3]       | {"x":1, "y":4} | {"a":1, "b":"x"} |
++-----------------+----------------+------------------+
+```
+
+```sql
+select min_by(k1, arr), min_by(mp, arr), min_by(st, arr), min_by(arr, arr) from tbl;
+```
+
+```text
++-----------------+-----------------+------------------+------------------+
+| min_by(k1, arr) | min_by(mp, arr) | min_by(st, arr)  | min_by(arr, arr) |
++-----------------+-----------------+------------------+------------------+
+|               0 | {"x":1, "y":4}  | {"a":1, "b":"x"} | [1, 2, 3]        |
++-----------------+-----------------+------------------+------------------+
+```
+
+```sql
+select min_by(k1, k2) from tbl where k1 is null;
+```
+
+```text
++----------------+
+| min_by(k1, k2) |
++----------------+
+|           NULL |
++----------------+
+```
+
+다음 배열 비교 예제는 Doris 4.1 계열의 4.1.5 이상 버전과 Doris 4.2 이상에 적용됩니다.
+
+```sql
+SELECT min_by(label, sort_key) AS result
+FROM (
+    SELECT 'null element' AS label, [1, NULL] AS sort_key
+    UNION ALL SELECT 'non-null element', [1, 2]
+    UNION ALL SELECT 'null array', CAST(NULL AS ARRAY<INT>)
+) t;
+```
+
+```text
+non-null element
+```
+
+```sql
+SELECT min_by(1, CAST(NULL AS ARRAY<INT>)) AS result;
+```
+
+```text
+NULL
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min-map.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min-map.md
new file mode 100644
index 00000000000..0ca8d79ee77
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min-map.md
@@ -0,0 +1,115 @@
+---
+{
+    "title": "MIN_MAP",
+    "language": "ko",
+    "description": "MIN_MAP 함수는 MAP 값을 키별로 집계하고 각 키의 최솟값을 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+MIN_MAP 함수는 MAP 값을 키별로 집계하고 각 키에 대해 NULL이 아닌 최솟값을 포함하는 MAP을 반환합니다.
+
+## 사용 시 참고 사항 {#usage-notes}
+
+반환되는 MAP 내 항목의 순서는 보장되지 않습니다. 일정한 출력 순서가 필요하면 `map_keys`, `map_values`, `array_sort`, `array_sortby`를 사용하세요. NULL 키도 일반 키와 동일하게 집계되며, 모든 NULL 키는 결과의 동일한 항목에 속합니다.
+
+## 구문 {#syntax}
+
+```sql
+MIN_MAP(<map_expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| --- | --- |
+| `<map_expr>` | MAP 표현식입니다. MAP 값 타입은 MIN 집계 함수로 비교할 수 있어야 합니다. |
+
+## 반환값 {#return-value}
+
+키 타입이 `<map_expr>`와 같은 MAP을 반환합니다. 값 타입이 DecimalV2이면 반환되는 값 타입은 이에 대응하는 DecimalV3 타입입니다. 그 외의 값 타입은 입력 MAP의 값 타입과 동일하게 반환됩니다.
+
+그룹에 유효한 입력 행이 없으면 빈 MAP을 반환합니다. 키가 존재하지만 해당 키의 모든 값이 NULL이면 해당 키의 값은 NULL입니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE map_agg_example (
+    id INT,
+    m MAP<INT, INT>,
+    ms MAP<INT, STRING>
+) DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO map_agg_example VALUES
+    (1, MAP(1, 10, 2, 20), MAP(1, 'b', 2, 'x')),
+    (1, MAP(2, 5, 3, 30), MAP(1, 'a', 3, NULL)),
+    (2, MAP(1, 7, 4, NULL), MAP(2, 'z')),
+    (2, CAST(MAP() AS MAP<INT, INT>), CAST(MAP() AS MAP<INT, STRING>));
+```
+
+```text
+Query OK
+```
+
+```sql
+SELECT id,
+       array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT id, MIN_MAP(m) AS result
+    FROM map_agg_example
+    GROUP BY id
+) t
+ORDER BY id;
+```
+
+```text
++------+-----------+-------------+
+| id   | keys      | values      |
++------+-----------+-------------+
+|    1 | [1, 2, 3] | [10, 5, 30] |
+|    2 | [1, 4]    | [7, null]   |
++------+-----------+-------------+
+```
+
+```sql
+SELECT id,
+       array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT id, MIN_MAP(ms) AS result
+    FROM map_agg_example
+    GROUP BY id
+) t
+ORDER BY id;
+```
+
+```text
++------+-----------+----------------+
+| id   | keys      | values         |
++------+-----------+----------------+
+|    1 | [1, 2, 3] | ["a", "x", null] |
+|    2 | [2]       | ["z"]          |
++------+-----------+----------------+
+```
+
+```sql
+SELECT array_sort(map_keys(result)) AS keys,
+       array_sortby(map_values(result), map_keys(result)) AS values
+FROM (
+    SELECT MIN_MAP(m) AS result
+    FROM map_agg_example
+    WHERE id = 100
+) t;
+```
+
+```text
++------+--------+
+| keys | values |
++------+--------+
+| []   | []     |
++------+--------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min.md
new file mode 100644
index 00000000000..90c899e3675
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/min.md
@@ -0,0 +1,135 @@
+---
+{
+    "title": "MIN",
+    "language": "ko",
+    "description": "MIN 함수는 표현식에서 NULL이 아닌 값 중 최솟값을 반환합니다."
+}
+---
+
+## 설명 {#description}
+
+MIN 함수는 표현식에서 NULL이 아닌 값 중 최솟값을 반환합니다.
+
+버전별 차이: Doris 4.1 계열의 4.1.5부터, 그리고 Doris 4.2 이상에서는 배열 내 `NULL` 요소가 `NULL`이 아닌 요소보다 큰 것으로 비교됩니다. Doris 4.0과 Doris 4.1의 4.1.5 이전 버전에서는 배열 내 `NULL` 요소가 더 작은 것으로 비교됩니다. 배열 값 전체가 `NULL`인 경우에는 이 모든 버전에서 무시됩니다.
+
+## 구문 {#syntax}
+
+```sql
+MIN(<expr>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| --- | --- |
+| `<expr>` | 값을 구할 표현식입니다. 지원되는 타입은 String, Time, Date, DateTime, Timestamptz, IPv4, IPv6, TinyInt, SmallInt, Integer, BigInt, LargeInt, Float, Double, Decimal, Array입니다. |
+
+## 반환값 {#return-value}
+
+입력 표현식과 동일한 데이터 타입을 반환합니다.
+그룹의 모든 레코드가 NULL이면 함수는 NULL을 반환합니다.
+
+:::caution 동작 변경 (4.1.5)
+
+Doris 4.1 계열의 4.1.5부터는 배열과 같은 복합 값 내부의 NULL 요소가 같은 위치의 NULL이 아닌 요소보다 큰 것으로 비교됩니다. 예를 들어, `[10, 20, NULL]`은 `[10, 20, 40]`보다 큽니다. 이는 표현식 전체가 NULL인 경우와 다르며, 표현식 전체가 NULL인 행은 여전히 무시됩니다. 4.1.5 이전에는 집계 비교에서 복합 값 내부의 NULL 요소를 더 작은 것으로 처리했습니다.
+
+:::
+
+## 예제 {#example}
+
+```sql
+-- setup
+create table t1(
+        k1 int,
+        k_string varchar(100),
+        k_decimal decimal(10, 2),
+        k_array array<int>
+) distributed by hash (k1) buckets 1
+properties ("replication_num"="1");
+insert into t1 values 
+    (1, 'apple', 10.01, [10, 20, 30]),
+    (1, 'banana', 20.02, [10, 20]),
+    (2, 'orange', 30.03, [10, 20, 40]),
+    (2, null, null, [10, 20, null]),
+    (3, null, null, null);
+```
+
+```text
+Table created and data inserted successfully.
+```
+
+```sql
+select k1, min(k_string) from t1 group by k1 order by k1;
+```
+
+String 타입: 각 그룹에서 문자열의 최솟값을 반환합니다.
+
+```text
++------+---------------+
+| k1   | min(k_string) |
++------+---------------+
+|    1 | apple         |
+|    2 | orange        |
+|    3 | NULL          |
++------+---------------+
+```
+
+```sql
+select k1, min(k_decimal) from t1 group by k1 order by k1;
+```
+
+Decimal 타입: 고정밀 소수의 최솟값을 반환합니다.
+
+```text
++------+----------------+
+| k1   | min(k_decimal) |
++------+----------------+
+|    1 |          10.01 |
+|    2 |          30.03 |
+|    3 |           NULL |
++------+----------------+
+```
+
+```sql
+select k1, min(k_array) from t1 group by k1 order by k1;
+```
+
+Array 타입: 요소를 순서대로 비교하여 각 그룹의 최소 배열 값을 반환합니다. NULL 요소는 같은 위치의 NULL이 아닌 요소보다 큰 것으로 비교됩니다.
+
+```text
++------+----------------+
+| k1   | min(k_array)   |
++------+----------------+
+|    1 | [10, 20]       |
+|    2 | [10, 20, 40]   |
+|    3 | NULL           |
++------+----------------+
+```
+
+```sql
+select min(k_string) from t1 where k1 = 3;
+```
+
+그룹의 모든 값이 NULL이면 NULL을 반환합니다.
+
+```text
++---------------+
+| min(k_string) |
++---------------+
+| NULL          |
++---------------+
+```
+
+```sql
+select min(k_string) from t1;
+```
+
+전체 데이터의 최솟값입니다.
+
+```text
++---------------+
+| min(k_string) |
++---------------+
+| apple         |
++---------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx-array.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx-array.md
new file mode 100644
index 00000000000..6e56436ac7e
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx-array.md
@@ -0,0 +1,108 @@
+---
+{
+    "title": "PERCENTILE_APPROX_ARRAY",
+    "language": "ko",
+    "description": "PERCENTILE_APPROX_ARRAY는 공유 T-Digest 상태를 사용하여 한 번의 집계로 여러 근사 백분위수를 계산합니다."
+}
+---
+
+## 설명 {#description}
+
+`PERCENTILE_APPROX_ARRAY`는 한 번의 집계로 여러 근사 백분위수를 계산합니다. 입력값으로 하나의 T-Digest를 생성하고 이 공유 상태에서 요청된 모든 백분위수를 계산하므로, 각 백분위수에 대해 `PERCENTILE_APPROX`를 개별적으로 호출하는 것보다 효율적입니다.
+
+:::note
+이 함수는 4.2.0부터 지원됩니다.
+:::
+
+## 구문 {#syntax}
+
+```sql
+PERCENTILE_APPROX_ARRAY(<col>, <quantiles> [, <compression>])
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<col>` | 백분위수를 계산할 숫자 표현식입니다. 값은 `DOUBLE`로 변환됩니다. `NULL` 값은 무시됩니다. |
+| `<quantiles>` | 상수 `ARRAY<DOUBLE>`입니다. 각 요소는 유한한 값이면서 NULL이 아니어야 하며, `[0.0, 1.0]` 범위에 있어야 합니다. 결과는 배열과 동일한 순서를 따르며, 중복된 백분위 수준도 그대로 유지됩니다. 빈 배열도 허용됩니다. |
+| `<compression>` | 선택 사항인 상수 `DOUBLE`로, 값은 `[2048, 10000]` 범위여야 합니다. 일반적으로 값이 클수록 정확도가 높아지지만 더 많은 메모리를 사용합니다. 기본값은 `10000`이며, 유한하지 않은 값이나 유효 범위를 벗어난 값에도 `10000`을 사용합니다. |
+
+## 반환값 {#return-value}
+
+근사 백분위수로 구성된 `ARRAY<DOUBLE>`을 반환하며, `<quantiles>`의 각 요소에 해당하는 결과가 하나씩 포함됩니다. 이 함수는 `<quantiles>`가 비어 있거나 그룹에 NULL이 아닌 입력값이 없으면 빈 배열을 반환합니다. 유효하지 않은 백분위 수준이나 `<quantiles>`의 NULL 요소는 오류를 발생시킵니다.
+
+## 예제 {#example}
+
+```sql
+CREATE TABLE percentile_approx_array_example (
+    id INT,
+    value DOUBLE NULL
+) DUPLICATE KEY(id)
+DISTRIBUTED BY HASH(id) BUCKETS 1
+PROPERTIES ("replication_num" = "1");
+
+INSERT INTO percentile_approx_array_example VALUES
+    (1, 1.0), (2, 2.0), (3, 3.0), (4, NULL),
+    (5, 10.0), (6, 20.0), (7, 30.0), (8, 100.0);
+```
+
+기본 압축 수준으로 여러 근사 백분위수를 계산합니다:
+
+```sql
+SELECT percentile_approx_array(value, [0.0, 0.25, 0.5, 0.75, 1.0]) AS percentiles
+FROM percentile_approx_array_example;
+```
+
+```text
++--------------------------+
+| percentiles              |
++--------------------------+
+| [1, 2.25, 10, 27.5, 100] |
++--------------------------+
+```
+
+압축 수준을 명시적으로 지정합니다:
+
+```sql
+SELECT percentile_approx_array(value, [0.25, 0.5, 0.75], 2048) AS percentiles
+FROM percentile_approx_array_example;
+```
+
+```text
++------------------+
+| percentiles      |
++------------------+
+| [2.25, 10, 27.5] |
++------------------+
+```
+
+모든 입력값이 NULL이면 빈 배열을 반환합니다:
+
+```sql
+SELECT percentile_approx_array(CAST(NULL AS DOUBLE), [0.0, 0.5, 1.0]) AS percentiles
+FROM percentile_approx_array_example;
+```
+
+```text
++-------------+
+| percentiles |
++-------------+
+| []          |
++-------------+
+```
+
+백분위수 배열이 비어 있어도 빈 배열을 반환합니다:
+
+```sql
+SELECT percentile_approx_array(value, []) AS percentiles
+FROM percentile_approx_array_example;
+```
+
+```text
++-------------+
+| percentiles |
++-------------+
+| []          |
++-------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx-weighted.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx-weighted.md
new file mode 100644
index 00000000000..628d7347623
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx-weighted.md
@@ -0,0 +1,109 @@
+---
+{
+    "title": "PERCENTILE_APPROX_WEIGHTED",
+    "language": "ko",
+    "description": "PERCENTILEAPPROXWEIGHTED 함수는 가중 근사 백분위수를 계산합니다,"
+}
+---
+
+## 설명 {#description}
+
+`PERCENTILE_APPROX_WEIGHTED` 함수는 가중 근사 백분위수를 계산하며, 주로 값의 중요도를 고려해야 하는 상황에서 사용합니다. `PERCENTILE_APPROX`에 가중치를 적용한 버전으로, 각 값에 가중치를 지정할 수 있습니다.
+
+주요 특징:
+1. 가중치 지원: 각 값에 가중치를 할당할 수 있으며, 이 가중치는 최종 백분위수 계산에 영향을 줍니다.
+2. 메모리 효율성: 고정 크기의 메모리를 사용하므로 카디널리티가 낮은 컬럼(데이터 양은 많지만 서로 다른 요소의 수는 적음)을 처리할 때도 메모리 사용량을 낮게 유지합니다.
+3. 정밀도 조정: 압축 매개변수를 통해 정밀도와 성능 간의 균형을 조절할 수 있습니다.
+
+## 구문 {#syntax}
+
+```sql
+PERCENTILE_APPROX_WEIGHTED(<col>, <weight>, <p> [, <compression>])
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<col>` | 백분위수를 계산할 컬럼입니다. 지원 타입: Double |
+| `<weight>` | 가중치 컬럼으로, 값은 양수여야 합니다. 지원 타입: Double |
+| `<p>` | 백분위수 값으로, 범위는 `[0.0, 1.0]`입니다. 예를 들어 `0.99`는 `99`번째 백분위수를 나타냅니다. |
+| `<compression>` | 선택적 매개변수이며, 지원 타입은 Double입니다. 압축률을 지정하며, 범위는 `[2048, 10000]`입니다. 값이 클수록 정밀도가 높아지지만 메모리 사용량도 증가합니다. 지정하지 않거나 범위를 벗어나면 `10000`을 사용합니다. |
+
+## 반환 값 {#return-value}
+
+계산된 가중 근사 백분위수를 나타내는 `DOUBLE` 타입의 값을 반환합니다.
+그룹에 유효한 데이터가 없으면 `NULL`을 반환합니다.
+
+## 예제 {#examples}
+
+```sql
+-- Create sample table
+CREATE TABLE weighted_scores (
+    student_id INT,
+    score DECIMAL(10, 2),
+    weight INT
+) DUPLICATE KEY(student_id)
+DISTRIBUTED BY HASH(student_id) BUCKETS AUTO
+PROPERTIES (
+    "replication_allocation" = "tag.location.default: 1"
+);
+
+-- Insert example data
+INSERT INTO weighted_scores VALUES
+(1, 85.5, 1),   -- Normal homework score, weight 1
+(2, 90.0, 2),   -- Important homework score, weight 2
+(3, 75.5, 1),
+(4, 95.5, 3),   -- Very important homework, weight 3
+(5, 88.0, 2),
+(6, 92.5, 2),
+(7, 78.0, 1),
+(8, 89.5, 2),
+(9, 94.0, 3),
+(10, 83.5, 1);
+
+-- Calculate weighted scores distribution
+SELECT 
+    -- Calculate 90th percentile for different compression ratios
+    percentile_approx_weighted(score, weight, 0.9) as p90_default,          -- Default compression ratio
+    percentile_approx_weighted(score, weight, 0.9, 2048) as p90_fast,       -- Lower compression ratio, faster
+    percentile_approx_weighted(score, weight, 0.9, 10000) as p90_accurate   -- Higher compression ratio, more accurate
+FROM weighted_scores;
+```
+
+```text
++------------------+------------------+------------------+
+| p90_default      | p90_fast         | p90_accurate     |
++------------------+------------------+------------------+
+| 95.3499984741211 | 95.3499984741211 | 95.3499984741211 |
++------------------+------------------+------------------+
+```
+
+
+```sql
+select percentile_approx_weighted(if(score>95,score,null), weight, 0.9) from weighted_scores;
+```
+
+NULL이 아닌 입력만 고려합니다.
+
+```text
++------------------------------------------------------------------+
+| percentile_approx_weighted(if(score>95,score,null), weight, 0.9) |
++------------------------------------------------------------------+
+|                                                             95.5 |
++------------------------------------------------------------------+
+```
+
+```sql
+select percentile_approx_weighted(score, weight, 0.9, null) from weighted_scores;
+```
+
+모든 입력값이 NULL이면 함수는 NULL을 반환합니다.
+
+```text
++------------------------------------------------------+
+| percentile_approx_weighted(score, weight, 0.9, null) |
++------------------------------------------------------+
+|                                                 NULL |
++------------------------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx.md
new file mode 100644
index 00000000000..56275b068bb
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-approx.md
@@ -0,0 +1,105 @@
+---
+{
+    "title": "PERCENTILE_APPROX",
+    "language": "ko",
+    "description": "PERCENTILEAPPROX 함수는 주로 대규모 데이터셋의 근사 백분위수를 계산하는 데 사용됩니다. PERCENTILE 함수와 비교하면,"
+}
+---
+
+## 설명 {#description}
+
+`PERCENTILE_APPROX` 함수는 주로 대규모 데이터셋의 근사 백분위수를 계산하는 데 사용됩니다. `PERCENTILE` 함수와 비교하면 다음과 같은 특징이 있습니다.
+
+1. 메모리 효율성: 고정 크기의 메모리를 사용하므로 카디널리티가 낮은 열(데이터 양은 많지만 서로 다른 요소의 수가 적은 열)을 처리할 때도 메모리 사용량을 낮게 유지합니다.
+2. 성능 이점: 계산 속도가 빨라 카디널리티가 낮은 대규모 데이터셋을 처리하기에 적합합니다.
+3. 정밀도 조정: 압축 매개변수를 통해 정밀도와 성능 간의 균형을 조정할 수 있습니다.
+
+
+## 구문 {#syntax}
+
+```sql
+PERCENTILE_APPROX(<col>, <p> [, <compression>])
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<col>` | 백분위수를 계산할 열입니다. 지원하는 타입은 Double입니다. |
+| `<p>` | 백분위수 값으로, Double 타입의 상수이며 범위는 `[0.0, 1.0]`입니다. 예를 들어 `0.99`는 99번째 백분위수를 의미합니다. 상수여야 합니다. |
+| `<compression>` | 선택 사항인 압축 수준으로, Double 타입이며 범위는 `[2048, 10000]`입니다. 값이 클수록 정밀도가 높아지지만 메모리를 더 많이 사용합니다. 지정하지 않거나 범위를 벗어나면 기본값인 `10000`을 사용합니다. |
+
+## 반환 값 {#return-value}
+
+지정된 열의 근사 백분위수를 Double 타입으로 반환합니다.
+그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#examples}
+
+```sql
+-- setup
+CREATE TABLE response_times (
+    request_id INT,
+    response_time DECIMAL(10, 2)
+) DUPLICATE KEY(`request_id`)
+DISTRIBUTED BY HASH(`request_id`) BUCKETS AUTO
+PROPERTIES (
+    "replication_allocation" = "tag.location.default: 1"
+);
+INSERT INTO response_times VALUES
+(1, 10.5),
+(2, 15.2),
+(3, 20.1),
+(4, 25.8),
+(5, 30.3),
+(6, 35.7),
+(7, 40.2),
+(8, 45.9),
+(9, 50.4),
+(10, 100.6);
+```
+
+```sql
+-- Calculate 99th percentile using different compression levels
+SELECT 
+    percentile_approx(response_time, 0.99) as p99_default,          -- Default compression
+    percentile_approx(response_time, 0.99, 2048) as p99_fast,       -- Lower compression, faster
+    percentile_approx(response_time, 0.99, 10000) as p99_accurate   -- Higher compression, more accurate
+FROM response_times;
+```
+
+```text
++-------------------+-------------------+-------------------+
+| p99_default       | p99_fast          | p99_accurate      |
++-------------------+-------------------+-------------------+
+| 100.5999984741211 | 100.5999984741211 | 100.5999984741211 |
++-------------------+-------------------+-------------------+
+```
+
+```sql
+SELECT percentile_approx(if(response_time>90,response_time,NULL), 0.5) FROM response_times;
+```
+
+NULL이 아닌 데이터만 계산에 사용됩니다.
+
+```text
++-----------------------------------------------------------------+
+| percentile_approx(if(response_time>90,response_time,NULL), 0.5) |
++-----------------------------------------------------------------+
+|                                               100.5999984741211 |
++-----------------------------------------------------------------+
+```
+
+```sql
+SELECT percentile_approx(NULL, 0.99) FROM response_times;
+```
+
+모든 입력 데이터가 NULL이면 NULL을 반환합니다.
+
+```text
++-------------------------------+
+| percentile_approx(NULL, 0.99)  |
++-------------------------------+
+|                          NULL  |
++-------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-array.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-array.md
new file mode 100644
index 00000000000..2e545f79d38
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile-array.md
@@ -0,0 +1,104 @@
+---
+{
+    "title": "PERCENTILE_ARRAY",
+    "language": "ko",
+    "description": "PERCENTILEARRAY 함수는 정확한 백분위수 배열을 계산하며, 여러 백분위수 값을 한 번에 계산할 수 있습니다."
+}
+---
+
+## 설명 {#description}
+
+`PERCENTILE_ARRAY` 함수는 정확한 백분위수 배열을 계산하며, 여러 백분위수 값을 한 번에 계산할 수 있습니다. 이 함수는 주로 소규모 데이터 세트에 적합합니다.
+
+주요 기능:
+1. 정확한 계산: 근삿값이 아닌 정확한 백분위수 결과를 제공합니다
+2. 일괄 처리: 한 번의 연산으로 여러 백분위수를 계산할 수 있습니다
+3. 적용 범위: 소규모 데이터 세트를 처리하는 데 가장 적합합니다
+
+
+## 구문 {#syntax}
+
+```sql
+PERCENTILE_ARRAY(<col>, <array_p>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<col>` | 정확한 백분위수를 계산할 컬럼입니다. 지원하는 타입: Double, Float, LargeInt, BigInt, Int, SmallInt, TinyInt. |
+| `<array_p>` | 백분위수 배열로, 각 요소는 Array<Double> 타입의 상수여야 하며 값은 `[0.0, 1.0]` 범위에 있어야 합니다. 예: `[0.5, 0.95, 0.99]`. |
+
+## 반환값 {#return-value}
+
+계산된 백분위수 값을 담은 DOUBLE 타입 배열을 반환합니다.
+그룹에 유효한 데이터가 없으면 빈 배열을 반환합니다.
+
+
+## 예제 {#examples}
+
+```sql
+-- setup
+CREATE TABLE sales_data (
+    id INT,
+    amount DECIMAL(10, 2)
+) DUPLICATE KEY(`id`)
+DISTRIBUTED BY HASH(`id`) BUCKETS AUTO
+PROPERTIES (
+    "replication_allocation" = "tag.location.default: 1"
+);
+INSERT INTO sales_data VALUES
+(1, 10.5),
+(2, 15.2),
+(3, 20.1),
+(4, 25.8),
+(5, 30.3),
+(6, 35.7),
+(7, 40.2),
+(8, 45.9),
+(9, 50.4),
+(10, 100.6);
+```
+
+```sql
+SELECT percentile_array(amount, [0.25, 0.5, 0.75, 0.9]) as percentiles
+FROM sales_data;
+```
+
+여러 백분위수를 계산합니다.
+
+```text
++-----------------------------------------------------+
+| percentiles                                         |
++-----------------------------------------------------+
+| [21.525000000000002, 33, 44.475, 55.41999999999998] |
++-----------------------------------------------------+
+```
+
+```sql
+SELECT percentile_array(if(amount>90, amount, NULL), [0.5, 0.99]) FROM sales_data;
+```
+
+NULL이 아닌 데이터만 계산에 사용합니다.
+
+```text
++------------------------------------------------------------+
+| percentile_array(if(amount>90, amount, NULL), [0.5, 0.99]) |
++------------------------------------------------------------+
+| [100.6, 100.6]                                             |
++------------------------------------------------------------+
+```
+
+```sql
+SELECT percentile_array(NULL, [0.5, 0.99]) FROM sales_data;
+```
+
+입력 데이터가 모두 NULL이면 빈 배열을 반환합니다.
+
+```text
++-------------------------------------+
+| percentile_array(NULL, [0.5, 0.99]) |
++-------------------------------------+
+| []                                  |
++-------------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile.md
new file mode 100644
index 00000000000..5516ec948be
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile.md
@@ -0,0 +1,103 @@
+---
+{
+    "title": "PERCENTILE",
+    "language": "ko",
+    "description": "정확한 백분위수를 계산하며, 작은 데이터 세트에 적합합니다. 먼저 지정된 열을 내림차순으로 정렬한 다음,"
+}
+---
+
+## 설명 {#description}
+
+정확한 백분위수를 계산하며, 작은 데이터 세트에 적합합니다. 먼저 지정된 열을 내림차순으로 정렬한 다음, 정확한 p번째 백분위수를 구합니다. `p`의 값은 `0`과 `1` 사이입니다. `p`가 정확한 위치를 가리키지 않으면, 인접한 값 사이의 [선형 보간](https://en.wikipedia.org/wiki/Linear_interpolation)을 통해 `p` 위치의 값을 반환합니다. 이 값은 두 수의 평균이 아니라는 점에 유의하세요. 특수한 경우:
+
+## 구문 {#syntax}
+
+```sql
+PERCENTILE(<col>, <p>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<col>` | 정확한 백분위수를 계산할 열입니다. 지원 타입: Double, Float, LargeInt, BigInt, Int, SmallInt, TinyInt. |
+| `<p>` | 계산할 정확한 백분위수로, 상수 값입니다. 지원 타입: Double. 범위: `[0.0, 1.0]`. 두 번째 매개변수는 상수여야 합니다. |
+
+## 반환 값 {#return-value}
+
+지정된 열의 정확한 백분위수를 반환하며, 반환 타입은 Double입니다.
+그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#examples}
+
+```sql
+-- Setup
+CREATE TABLE sales_data
+(
+    product_id INT,
+    sale_price DECIMAL(10, 2)
+) DUPLICATE KEY(`product_id`)
+DISTRIBUTED BY HASH(`product_id`) BUCKETS AUTO
+PROPERTIES (
+    "replication_allocation" = "tag.location.default: 1"
+);
+INSERT INTO sales_data VALUES
+(1, 10.00),
+(1, 15.00),
+(1, 20.00),
+(1, 25.00),
+(1, 30.00),
+(1, 35.00),
+(1, 40.00),
+(1, 45.00),
+(1, 50.00),
+(1, 100.00);
+```
+
+```sql
+SELECT 
+    percentile(sale_price, 0.5)  as median_price,     -- Median
+    percentile(sale_price, 0.75) as p75_price,        -- 75th percentile
+    percentile(sale_price, 0.90) as p90_price,        -- 90th percentile
+    percentile(sale_price, 0.95) as p95_price,        -- 95th percentile
+    percentile(null, 0.99)       as p99_null          -- Null value at 99th percentile
+FROM sales_data;
+```
+
+다양한 백분위수에 해당하는 판매 가격을 계산합니다.
+
+```text
++--------------+-----------+-------------------+-------------------+----------+
+| median_price | p75_price | p90_price         | p95_price         | p99_null |
++--------------+-----------+-------------------+-------------------+----------+
+|         32.5 |     43.75 | 54.99999999999998 | 77.49999999999994 |     NULL |
++--------------+-----------+-------------------+-------------------+----------+
+```
+
+```sql
+select percentile(if(sale_price>90,sale_price,NULL), 0.5) from sales_data;
+```
+
+NULL이 아닌 입력 값만 계산에 사용합니다.
+
+```text
++----------------------------------------------------+
+| percentile(if(sale_price>90,sale_price,NULL), 0.5) |
++----------------------------------------------------+
+|                                                100 |
++----------------------------------------------------+
+```
+
+```sql
+select percentile(sale_price, NULL) from sales_data;
+```
+
+모든 입력 값이 NULL이면 NULL을 반환합니다.
+
+```text
++------------------------------+
+| percentile(sale_price, NULL) |
++------------------------------+
+|                         NULL |
++------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile_reservoir.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile_reservoir.md
new file mode 100644
index 00000000000..edc0539c103
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/percentile_reservoir.md
@@ -0,0 +1,90 @@
+---
+{
+    "title": "PERCENTILE_RESERVOIR",
+    "language": "ko",
+    "description": "이 함수는 리저버 크기가 최대 8192인 reservoir sampling을 적용하며, 샘플링에 난수 생성기를 사용합니다."
+}
+---
+
+## 설명 {#description}
+
+이 함수는 리저버 크기가 최대 8192인 [reservoir sampling](https://en.wikipedia.org/wiki/Reservoir_sampling)을 적용하며, 샘플링에 난수 생성기를 사용합니다. 위치 `p`에서의 근사 백분위수를 계산하는 데 사용됩니다.
+`p`의 값은 `0`과 `1` 사이입니다.
+두 수의 평균을 구하는 것은 아니라는 점에 유의하세요.
+
+## 구문 {#syntax}
+
+```sql
+PERCENTILE_RESERVOIR(<col>, <p>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<col>` | 근사 백분위수를 계산할 컬럼입니다. 지원 타입: Double |
+| `<p>` | 계산할 근사 백분위수로, 상수 값입니다. 지원 타입: Double, 값 범위: `[0.0, 1.0]`. |
+
+## 반환값 {#return-value}
+
+지정된 컬럼의 근사 백분위수를 반환하며, 반환 타입은 `DOUBLE`입니다.
+- `NULL`을 반환합니다(입력 컬럼이 `NULL`인 경우).
+
+## 예제 {#examples}
+
+```sql
+-- Create sample table
+CREATE TABLE sales_data
+(
+    product_id INT,
+    sale_price DECIMAL(10, 2)
+) DUPLICATE KEY(`product_id`)
+DISTRIBUTED BY HASH(`product_id`) BUCKETS AUTO
+PROPERTIES (
+    "replication_allocation" = "tag.location.default: 1"
+);
+
+-- Insert sample data
+INSERT INTO sales_data VALUES
+(1, 10.00),
+(1, 15.00),
+(1, 20.00),
+(1, 25.00),
+(1, 30.00),
+(1, 35.00),
+(1, 40.00),
+(1, 45.00),
+(1, 50.00),
+(1, 100.00);
+
+-- Calculate different percentiles of sales prices
+SELECT 
+    percentile_reservoir(sale_price, 0.5)  as median_price,     -- Median
+    percentile_reservoir(sale_price, 0.75) as p75_price,        -- 75th percentile
+    percentile_reservoir(sale_price, 0.90) as p90_price,        -- 90th percentile
+    percentile_reservoir(sale_price, 0.95) as p95_price,        -- 95th percentile
+    percentile_reservoir(null, 0.99)       as p99_null          -- Null value at 99th percentile
+FROM sales_data;
+```
+
+```text
++--------------+-----------+-------------------+-------------------+----------+
+| median_price | p75_price | p90_price         | p95_price         | p99_null |
++--------------+-----------+-------------------+-------------------+----------+
+|         32.5 |     43.75 | 54.99999999999998 | 77.49999999999994 |     NULL |
++--------------+-----------+-------------------+-------------------+----------+
+```
+
+```sql
+select percentile_reservoir(sale_price, NULL) from sales_data;
+```
+
+모든 입력값이 NULL이면 NULL을 반환합니다.
+
+```text
++------------------------------+
+| percentile_reservoir(sale_price, NULL) |
++------------------------------+
+|                         NULL |
++------------------------------+
+```
diff --git a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/quantile-union.md b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/quantile-union.md
new file mode 100644
index 00000000000..f4ef8ec89a5
--- /dev/null
+++ b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/sql-manual/sql-functions/aggregate-functions/quantile-union.md
@@ -0,0 +1,93 @@
+---
+{
+    "title": "QUANTILE_UNION",
+    "language": "ko",
+    "description": "QUANTILEUNION 함수는 분위수 계산의 여러 중간 결과를 병합하는 데 사용됩니다."
+}
+---
+
+## 설명 {#description}
+
+`QUANTILE_UNION` 함수는 분위수 계산의 여러 중간 결과를 병합하는 데 사용됩니다. 이 함수는 일반적으로 `QUANTILE_STATE`와 함께 사용하며, 특히 여러 단계에 걸쳐 분위수를 계산해야 하는 시나리오에 적합합니다.
+
+## 구문 {#syntax}
+
+```sql
+QUANTILE_UNION(<query_state>)
+```
+
+## 매개변수 {#parameters}
+
+| 매개변수 | 설명 |
+| -- | -- |
+| `<query_state>` | 집계할 데이터로, QuantileState 타입을 지원합니다. |
+
+## 반환 값 {#return-value}
+
+추가 분위수 계산에 사용할 집계 상태를 반환하며, 반환 타입은 QuantileState입니다.
+그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+## 예제 {#example}
+
+```sql
+-- setup
+CREATE TABLE response_times (
+    request_id INT,
+    response_time DOUBLE,
+    region STRING
+) DUPLICATE KEY(request_id)
+DISTRIBUTED BY HASH(request_id) BUCKETS AUTO
+PROPERTIES (
+    "replication_allocation" = "tag.location.default: 1"
+);
+INSERT INTO response_times VALUES
+(1, 10.5, 'east'),
+(2, 15.2, 'east'),
+(3, 20.1, 'west'),
+(4, 25.8, 'east'),
+(5, 30.3, 'west'),
+(6, 35.7, 'east'),
+(7, 40.2, 'west'),
+(8, 45.9, 'east'),
+(9, 50.4, 'west'),
+(10, 100.6, 'east');
+```
+
+```sql
+SELECT 
+    region,
+    QUANTILE_PERCENT(
+        QUANTILE_UNION(
+            TO_QUANTILE_STATE(response_time, 2048)
+        ),
+        0.5
+    ) AS median_response_time
+FROM response_times
+GROUP BY region;
+```
+
+지역별 응답 시간의 50번째 백분위수를 계산합니다.
+
+```text
++--------+----------------------+
+| region | median_response_time |
++--------+----------------------+
+| west   |                35.25 |
+| east   |                30.75 |
++--------+----------------------+
+```
+
+```sql
+SELECT QUANTILE_UNION(TO_QUANTILE_STATE(response_time, 2048))
+FROM response_times where response_time is null;
+```
+
+그룹에 유효한 데이터가 없으면 NULL을 반환합니다.
+
+```text
++--------------------------------------------------------+
+| QUANTILE_UNION(TO_QUANTILE_STATE(response_time, 2048)) |
... 8373 lines suppressed ...


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@doris.apache.org
For additional commands, e-mail: commits-help@doris.apache.org