…d by FieldType

### What problem does this PR solve?

Issue Number: None

Related PR: apache#68608, apache#68609

Problem Summary: How a compute-layer value becomes the value a segment stores
is written down in several places. PrimitiveTypeConvertor<PT> gives the V1
DATE, DATETIME and DECIMAL layouts to the key encodings of RowCursor and the
BKD index; KeyCoderTraitsForFloat canonicalises NaN on its own; and the
comparison and IN-list predicates repeat the V1 conversions by hand to probe a
bloom filter. The key-encodable types are listed as (FieldType, PrimitiveType)
pairs so that the key helpers can be keyed by PrimitiveType.

Add storage/storage_layout.h. For every fixed-width FieldType,
StorageLayout<FT> gives the StorageValue a segment stores, the PrimitiveValue
the compute layer holds, and to_storage from one to the other: a bit cast, the
quiet NaN for every NaN of FLOAT/DOUBLE, and the V1 packing of DATE, DATETIME
and DECIMAL. FLOAT and DOUBLE also give that NaN rule as canonicalize_nan, for
code that already holds a stored value. Make the PrimitiveType <-> FieldType
mapping in storage_field_type.h constexpr, so that a template picks its layout
with StorageLayout<primitive_type_to_storage_field_type(PT)>; data_type.h now
declares FieldType itself instead of including that header.

Move the users onto it: full_encode_field_as_key and so the RowCursor and BKD
query key encodings, the BKD +/- infinity sentinels, KeyCoderTraitsForFloat,
which canonicalises the NaN of the value it encodes through canonicalize_nan,
and the bloom filter probes of the comparison and IN-list predicates. The
key-encodable types are listed by FieldType alone. Delete
PrimitiveTypeConvertor, whose last user was a test helper.

Every conversion is the one it replaces, so no stored or encoded byte changes.
The one difference is that a bloom filter probe now canonicalises a NaN, and no
bloom filter index is built on FLOAT or DOUBLE.

This is the second piece split out of apache#68608; the page encoders and decoders
move onto StorageLayout in later pieces.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - StorageLayoutTest (new): the StorageValue size of every fixed-width
      FieldType, the V1 DATE, DATETIME and DECIMAL packing, NaN
      canonicalisation and bit casts
    - KeyCoderTest (key order of full_encode_field_as_key for every key type),
      TestRowCursor, StorageFieldTypeTest, DateBloomFilterTest,
      BloomFilterIndexReaderWriterTest, BlockColumnPredicateTest,
      PredicateCreatorTest, InvertedIndexReaderTest (BKD range queries of
      every key type), SniiBkd*, and SegmentFlusherFormatTest and
      SegmentFlusherTransformFormatTest with strict golden comparison
- Behavior changed: No
- Does this need documentation: No

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

…d by FieldType

### What problem does this PR solve?

Issue Number: None

Related PR: apache#68608, apache#68609

Problem Summary: How a compute-layer value becomes the value a segment stores
is written down in several places. PrimitiveTypeConvertor<PT> gives the V1
DATE, DATETIME and DECIMAL layouts to the key encodings of RowCursor and the
BKD index; KeyCoderTraitsForFloat canonicalises NaN on its own; and the
comparison and IN-list predicates repeat the V1 conversions by hand to probe a
bloom filter. The key-encodable types are listed as (FieldType, PrimitiveType)
pairs so that the key helpers can be keyed by PrimitiveType.

Add storage/storage_layout.h. For every fixed-width FieldType,
StorageLayout<FT> gives the StorageValue a segment stores, the PrimitiveValue
the compute layer holds, and to_storage from one to the other: a bit cast, the
quiet NaN for every NaN of FLOAT/DOUBLE, and the V1 packing of DATE, DATETIME
and DECIMAL. FLOAT and DOUBLE also give that NaN rule as canonicalize_nan, for
code that already holds a stored value. StorageValue and PrimitiveValue are
taken from the two layers' own tables, CppTypeTraits and PrimitiveTypeTraits,
and defined nowhere else. Make the PrimitiveType <-> FieldType mapping in
storage_field_type.h constexpr, so that a template picks its layout with
StorageLayout<primitive_type_to_storage_field_type(PT)>; data_type.h now
declares FieldType itself instead of including that header.

Move the users onto it: full_encode_field_as_key and so the RowCursor and BKD
query key encodings, the BKD +/- infinity sentinels, KeyCoderTraitsForFloat,
which canonicalises the NaN of the value it encodes through canonicalize_nan,
and the bloom filter probes of the comparison and IN-list predicates. The
key-encodable types are listed by FieldType alone. Delete
PrimitiveTypeConvertor, whose last user was a test helper.

Every conversion is the one it replaces, so no stored or encoded byte changes.
The one difference is that a bloom filter probe now canonicalises a NaN, and no
bloom filter index is built on FLOAT or DOUBLE.

This is the second piece split out of apache#68608; the page encoders and decoders
move onto StorageLayout in later pieces.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - StorageLayoutTest (new): the StorageValue size of every fixed-width
      FieldType, the V1 DATE, DATETIME and DECIMAL packing, NaN
      canonicalisation and bit casts
    - KeyCoderTest (key order of full_encode_field_as_key for every key type),
      TestRowCursor, StorageFieldTypeTest, DateBloomFilterTest,
      BloomFilterIndexReaderWriterTest, BlockColumnPredicateTest,
      PredicateCreatorTest, InvertedIndexReaderTest (BKD range queries of
      every key type), SniiBkd*, and SegmentFlusherFormatTest and
      SegmentFlusherTransformFormatTest with strict golden comparison
- Behavior changed: No
- Does this need documentation: No

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

…d by FieldType

### What problem does this PR solve?

Issue Number: None

Related PR: apache#68608, apache#68609

Problem Summary: How a compute-layer value becomes the value a segment stores
is written down in several places. PrimitiveTypeConvertor<PT> gives the V1
DATE, DATETIME and DECIMAL layouts to the key encodings of RowCursor and the
BKD index; KeyCoderTraitsForFloat canonicalises NaN on its own; and the
comparison and IN-list predicates repeat the V1 conversions by hand to probe a
bloom filter. The key-encodable types are listed as (FieldType, PrimitiveType)
pairs so that the key helpers can be keyed by PrimitiveType.

Add storage/storage_layout.h. For every fixed-width FieldType,
StorageLayout<FT> gives the StorageValue a segment stores, the PrimitiveValue
the compute layer holds, and to_storage from one to the other: a bit cast, the
quiet NaN for every NaN of FLOAT/DOUBLE, and the V1 packing of DATE, DATETIME
and DECIMAL. FLOAT and DOUBLE also give that NaN rule as canonicalize_nan, for
code that already holds a stored value. The types are the two layers' own,
PrimitiveTypeTraits<PT>::CppType and CppTypeTraits<FT>::CppType, and callers
name them that way; the StorageValue and PrimitiveValue aliases inside
StorageLayout are its private shorthand. Make the PrimitiveType <-> FieldType
mapping in storage_field_type.h constexpr, so that a template picks its layout
with StorageLayout<primitive_type_to_storage_field_type(PT)>; data_type.h now
declares FieldType itself instead of including that header.

Move the users onto it: full_encode_field_as_key and so the RowCursor and BKD
query key encodings, the BKD +/- infinity sentinels, KeyCoderTraitsForFloat,
which canonicalises the NaN of the value it encodes through canonicalize_nan,
and the bloom filter probes of the comparison and IN-list predicates. The
key-encodable types are listed by FieldType alone. Delete
PrimitiveTypeConvertor, whose last user was a test helper.

Every conversion is the one it replaces, so no stored or encoded byte changes.
The one difference is that a bloom filter probe now canonicalises a NaN, and no
bloom filter index is built on FLOAT or DOUBLE.

This is the second piece split out of apache#68608; the page encoders and decoders
move onto StorageLayout in later pieces.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - StorageLayoutTest (new): the StorageValue size of every fixed-width
      FieldType, the V1 DATE, DATETIME and DECIMAL packing, NaN
      canonicalisation and bit casts
    - KeyCoderTest (key order of full_encode_field_as_key for every key type),
      TestRowCursor, StorageFieldTypeTest, DateBloomFilterTest,
      BloomFilterIndexReaderWriterTest, BlockColumnPredicateTest,
      PredicateCreatorTest, InvertedIndexReaderTest (BKD range queries of
      every key type), SniiBkd*, and SegmentFlusherFormatTest and
      SegmentFlusherTransformFormatTest with strict golden comparison
- Behavior changed: No
- Does this need documentation: No

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

…d by FieldType

### What problem does this PR solve?

Issue Number: None

Related PR: apache#68608, apache#68609

Problem Summary: How a compute-layer value becomes the value a segment stores
is written down in several places. PrimitiveTypeConvertor<PT> gives the V1
DATE, DATETIME and DECIMAL layouts to the key encodings of RowCursor and the
BKD index; KeyCoderTraitsForFloat canonicalises NaN on its own; and the
comparison and IN-list predicates repeat the V1 conversions by hand to probe a
bloom filter. The key-encodable types are listed as (FieldType, PrimitiveType)
pairs so that the key helpers can be keyed by PrimitiveType.

Add storage/storage_layout.h. For every fixed-width FieldType,
StorageLayout<FT> gives the StorageValue a segment stores, the PrimitiveValue
the compute layer holds, and to_storage from one to the other: a bit cast, the
quiet NaN for every NaN of FLOAT/DOUBLE, and the V1 packing of DATE, DATETIME
and DECIMAL. FLOAT and DOUBLE also give that NaN rule as canonicalize_nan, for
code that already holds a stored value. The types are the two layers' own,
PrimitiveTypeTraits<PT>::CppType and CppTypeTraits<FT>::CppType, and callers
name them that way; the StorageValue and PrimitiveValue aliases inside
StorageLayout are its private shorthand. Make the PrimitiveType <-> FieldType
mapping in storage_field_type.h constexpr, so that a template picks its layout
with StorageLayout<primitive_type_to_storage_field_type(PT)>; data_type.h now
declares FieldType itself instead of including that header.

Move the users onto it: full_encode_field_as_key and so the RowCursor and BKD
query key encodings, the BKD +/- infinity sentinels, KeyCoderTraitsForFloat,
which canonicalises the NaN of the value it encodes through canonicalize_nan,
and the bloom filter probes of the comparison and IN-list predicates. The
key-encodable types are listed by FieldType alone. Delete
PrimitiveTypeConvertor, whose last user was a test helper.

Every conversion is the one it replaces, so no stored or encoded byte changes.
The one difference is that a bloom filter probe now canonicalises a NaN, and no
bloom filter index is built on FLOAT or DOUBLE.

This is the second piece split out of apache#68608; the page encoders and decoders
move onto StorageLayout in later pieces.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - StorageLayoutTest (new): the StorageValue size of every fixed-width
      FieldType, the V1 DATE, DATETIME and DECIMAL packing, NaN
      canonicalisation and bit casts
    - KeyCoderTest (key order of full_encode_field_as_key for every key type),
      TestRowCursor, StorageFieldTypeTest, DateBloomFilterTest,
      BloomFilterIndexReaderWriterTest, BlockColumnPredicateTest,
      PredicateCreatorTest, InvertedIndexReaderTest (BKD range queries of
      every key type), SniiBkd*, and SegmentFlusherFormatTest and
      SegmentFlusherTransformFormatTest with strict golden comparison
- Behavior changed: No
- Does this need documentation: No

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

…d by FieldType (#68664)

### What problem does this PR solve?

Issue Number: None

Related PR: #68608, #68609

Problem Summary: How a compute-layer value becomes the value a segment
stores is written down in several places. PrimitiveTypeConvertor<PT>
gives the V1 DATE, DATETIME and DECIMAL layouts to the key encodings of
RowCursor and the BKD index; KeyCoderTraitsForFloat canonicalises NaN on
its own; and the comparison and IN-list predicates repeat the V1
conversions by hand to probe a bloom filter. The key-encodable types are
listed as (FieldType, PrimitiveType) pairs so that the key helpers can
be keyed by PrimitiveType.

Add storage/storage_layout.h. For every fixed-width FieldType,
StorageLayout<FT> gives the StorageValue a segment stores, the
PrimitiveValue the compute layer holds, and to_storage from one to the
other: a bit cast, the quiet NaN for every NaN of FLOAT/DOUBLE, and the
V1 packing of DATE, DATETIME and DECIMAL. Make the PrimitiveType <->
FieldType mapping in storage_field_type.h constexpr, so that a template
picks its layout with
StorageLayout<primitive_type_to_storage_field_type(PT)>; data_type.h now
declares FieldType itself instead of including that header.

Move the users onto it: full_encode_field_as_key and so the RowCursor
and BKD query key encodings, the BKD +/- infinity sentinels, the NaN
handling of KeyCoderTraitsForFloat, and the bloom filter probes of the
comparison and IN-list predicates. The key-encodable types are listed by
FieldType alone. Delete PrimitiveTypeConvertor, whose last user was a
test helper.

### What problem does this PR solve?

Issue Number: close #xxx

Related PR: #xxx

Problem Summary:

### Release note

None

### Check List (For Author)

- Test <!-- At least one of them must be included. -->
    - [ ] Regression test
    - [ ] Unit Test
    - [ ] Manual test (add detailed scripts or steps below)
    - [ ] No need to test or manual test. Explain why:
- [ ] This is a refactor/code format and no logic has been changed.
        - [ ] Previous test can cover this change.
        - [ ] No code files have been changed.
        - [ ] Other reason <!-- Add your reason?  -->

- Behavior changed:
    - [ ] No.
    - [ ] Yes. <!-- Explain the behavior change -->

- Does this need documentation?
    - [ ] No.
- [ ] Yes. <!-- Add document PR link here. eg:
apache/doris-website#1214 -->

### Check List (For Reviewer who merge this PR)

- [ ] Confirm the release note
- [ ] Confirm test cases
- [ ] Confirm document
- [ ] Add branch pick label <!-- Add branch pick label that this PR
should merge into -->

Co-authored-by: Claude Opus 5.5 (1M context) <[email protected]>

…padding

### What problem does this PR solve?

Issue Number: None

Related PR: apache#68608, apache#68609, apache#68664

Problem Summary: The short key, primary key and cluster key encodings, and the
MoW probes of partial update, row binlog derivation and historical row lookup,
read their key columns through OlapBlockDataConvertor, the copy of each block
the segment writer makes in storage layout. That copy is what pads CHAR values
to their declared length, so the key encodings depended on it for the padding
a short key needs, and every data page, dictionary, zone map, bloom filter and
inverted index of a CHAR column stored the padding too.

RowKeyEncoder now encodes from the block's own columns at absolute row numbers:
a fixed-width key value goes through StorageLayout<FT>::storage_at, and a CHAR
key is padded into the key by StorageLayout<CHAR>::append_padded, which the
RowCursor seek keys use as well. VerticalSegmentWriter collects its key,
sequence and cluster key columns from the block, and the MoW probe paths pass
block columns instead of converting them. The keys are byte for byte the ones
the converter path produced.

With no one left reading padded CHAR values from the converter, it stops
padding them: a CHAR column is converted like VARCHAR, and its data pages,
dictionary pages, zone maps, bloom filters and inverted indexes store the
value's own bytes. Segments written before still read the same: the CHAR page
pre-decoders strip the padding of data and dictionary pages, a zone map bound
of a CHAR column is cut at its first '\0', and CLucene cuts an indexed value at
its first '\0'. A bloom filter cannot tell padded hashes from unpadded ones,
which is why CHAR predicates already skip bloom filters, and they keep doing
so. The goldens that change are the 6 CHAR cases of PageFormatTest and the 32
SegmentFlusherFormatTest cases with a CHAR column; the other 82 and 41 cases
keep their bytes.

### Release note

CHAR columns are stored without their zero padding outside the key encodings,
so their data pages and zone maps get smaller. Query results do not change.

### Check List (For Author)

- Test: Unit Test
    - StorageLayoutTest (storage_at, append_padded), RowKeyEncoderTest,
      KeyCoderTest, KeyProbeTest, RowCacheProbeTest, FixedPartialUpdateTest,
      FlexiblePartialUpdateTest, HistoricalRowRetrieverTest,
      VerticalSegmentWriterWritePathsTest (two new MoW cases: appends past
      row 0, and a sequence column grouped away from its schema position),
      VerticalSegmentWriterMowCheckTest, PageFormatTest,
      SegmentFlusherFormatTest and SegmentFlusherTransformFormatTest with
      strict golden comparison, ColumnZoneMapTest, BinaryPlainPageV2Test,
      BinaryPlainPageV3Test, EncodingInfoTest, ColumnReaderTest, TestRowCursor,
      OlapDataConvertorTest
- Behavior changed: Yes. New segments store CHAR unpadded outside the key
  encodings; reads of old and new segments return the same values.
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>

…padding

Issue Number: None

Related PR: apache#68608, apache#68609, apache#68664

Problem Summary: The short key, primary key and cluster key encodings, and the
MoW probes of partial update, row binlog derivation and historical row lookup,
read their key columns through OlapBlockDataConvertor, the copy of each block
the segment writer makes in storage layout. That copy is what pads CHAR values
to their declared length, so the key encodings depended on it for the padding
a short key needs, and every data page, dictionary, zone map, bloom filter and
inverted index of a CHAR column stored the padding too.

RowKeyEncoder now encodes from the block's own columns at absolute row numbers:
a fixed-width key value goes through StorageLayout<FT>::storage_at, and a CHAR
key is padded into the key by StorageLayout<CHAR>::append_padded, which the
RowCursor seek keys use as well. VerticalSegmentWriter collects its key,
sequence and cluster key columns from the block, and the MoW probe paths pass
block columns instead of converting them. The keys are byte for byte the ones
the converter path produced.

With no one left reading padded CHAR values from the converter, it stops
padding them: a CHAR column is converted like VARCHAR, and its data pages,
dictionary pages, zone maps, bloom filters and inverted indexes store the
value's own bytes. Segments written before still read the same: the CHAR page
pre-decoders strip the padding of data and dictionary pages, a zone map bound
of a CHAR column is cut at its first '\0', and CLucene cuts an indexed value at
its first '\0'. A bloom filter cannot tell padded hashes from unpadded ones,
which is why CHAR predicates already skip bloom filters, and they keep doing
so. The goldens that change are the 6 CHAR cases of PageFormatTest and the 32
SegmentFlusherFormatTest cases with a CHAR column; the other 82 and 41 cases
keep their bytes.

CHAR columns are stored without their zero padding outside the key encodings,
so their data pages and zone maps get smaller. Query results do not change.

- Test: Unit Test
    - StorageLayoutTest (storage_at, append_padded), RowKeyEncoderTest,
      KeyCoderTest, KeyProbeTest, RowCacheProbeTest, FixedPartialUpdateTest,
      FlexiblePartialUpdateTest, HistoricalRowRetrieverTest,
      VerticalSegmentWriterWritePathsTest (two new MoW cases: appends past
      row 0, and a sequence column grouped away from its schema position),
      VerticalSegmentWriterMowCheckTest, PageFormatTest,
      SegmentFlusherFormatTest and SegmentFlusherTransformFormatTest with
      strict golden comparison, ColumnZoneMapTest, BinaryPlainPageV2Test,
      BinaryPlainPageV3Test, EncodingInfoTest, ColumnReaderTest, TestRowCursor,
      OlapDataConvertorTest
- Behavior changed: Yes. New segments store CHAR unpadded outside the key
  encodings; reads of old and new segments return the same values.
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>

…ockDataConvertor

### What problem does this PR solve?

Related PR: apache#68608, apache#68609, apache#68664

Problem Summary: Segment writing materializes block columns into intermediate
storage buffers through OlapBlockDataConvertor before feeding column writers,
indexes, and key encoders. Remove that intermediate converter and let these
consumers read column ranges directly through IColumn, row position, and count.

Share nullable-run processing, array index inputs, and StorageLayout conversion.
Encode keys from block columns and migrate partial-update, variant, and BUILD
INDEX paths. Keep page builders on one raw-byte add interface, with ColumnWriter
supplying physical fixed-width values or Slice descriptors and recording only
the rows accepted by each page. Convert directly into Plain/Bitshuffle buffers,
bound FOR conversion scratch, and reuse string and object serialization buffers.

Preserve CHAR padding, key encoding, and on-disk page layouts. Update writer,
index, and storage-layout tests and adapt existing callers to the new APIs.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - ASAN BE build and selected BE UT build with -j 128; 129 tests in 14 suites
    - Writer/physical-page byte and boundary comparison, page format golden tests,
      storage layout tests, and vertical segment writer tests
    - clang-format 16, build hygiene, and clang-tidy on changed lines passed
    - These checks ran on the identical source tree before this history-only
      squash; the before/after Git tree IDs were verified equal
    - Full cluster SQL regression and throughput benchmarks were not rerun
      for the final page-interface refactoring
- Behavior changed: No; internal write-path refactoring
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>

…ockDataConvertor

### What problem does this PR solve?

Related PR: apache#68608, apache#68609, apache#68664

Problem Summary: Segment writing materializes block columns into intermediate
storage buffers through OlapBlockDataConvertor before feeding column writers,
indexes, and key encoders. Remove that intermediate converter and let these
consumers read column ranges directly through IColumn, row position, and count.

Share nullable-run processing, array index inputs, and StorageLayout conversion.
Encode keys from block columns and migrate partial-update, variant, and BUILD
INDEX paths. Keep page builders on one raw-byte add interface, with ColumnWriter
supplying physical fixed-width values or Slice descriptors and recording only
the rows accepted by each page. Convert directly into Plain/Bitshuffle buffers,
bound FOR conversion scratch, and reuse string and object serialization buffers.

Preserve CHAR padding, key encoding, and on-disk page layouts. Update writer,
index, and storage-layout tests and adapt existing callers to the new APIs.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - ASAN BE build and selected BE UT build with -j 128; 129 tests in 14 suites
    - Writer/physical-page byte and boundary comparison, page format golden tests,
      storage layout tests, and vertical segment writer tests
    - clang-format 16, build hygiene, and clang-tidy on changed lines passed
    - These checks ran on the identical source tree before this history-only
      squash; the before/after Git tree IDs were verified equal
    - Full cluster SQL regression and throughput benchmarks were not rerun
      for the final page-interface refactoring
- Behavior changed: No; internal write-path refactoring
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>

…ockDataConvertor

### What problem does this PR solve?

Related PR: apache#68608, apache#68609, apache#68664, apache#69221

Problem Summary: Segment writing materializes block columns into intermediate
storage buffers through OlapBlockDataConvertor before feeding column writers,
indexes, and key encoders. Remove that intermediate converter and let these
consumers read column ranges directly through IColumn, row position, and count.

Share nullable-run processing, array index inputs, and StorageLayout conversion.
Encode keys from block columns and migrate partial-update, variant, and BUILD
INDEX paths. Keep page builders on one raw-byte add interface, with ColumnWriter
supplying physical fixed-width values or Slice descriptors and recording only
the rows accepted by each page.

The scalar writer follows the structure StarRocks' ScalarColumnWriter::_append
uses: a batch is first turned into contiguous storage cells, then one loop in
the base class splits the cells into NULL and value runs, feeds every run to
the page builder and the indexes, and flushes full pages.

- `StorageLayout<FT>::column_to_storage` has one signature for every type:
  `(column, row_pos, n, StorageBuffers&, null_map)`. It borrows the column's
  bytes when they are stored unchanged and otherwise fills the caller's
  `StorageBuffers` (converted bytes and Slice descriptors). CHAR keeps a
  length-taking overload that pads; BITMAP/HLL/QUANTILE_STATE serialise a whole
  batch the way the removed convertor did; AGG_STATE describes fixed-length
  objects.
- `ScalarColumnWriter` is one concrete class: `append` peels the null map,
  `prepare_cells` turns the batch into cells through the StorageLayout of
  `_layout_type` (the column's type, or what an AGG_STATE function serialises
  to, decided once at construction) and rejects a batch before anything is
  written, and `append_values` is the single run/page loop that feeds the
  page builder, every index, the row ids and the null bits. The composite
  writers feed their null maps through `append_values` directly; the offset
  writer only adds the `n + 1` offsets check and annotates the page footer
  from `page_accepted`, which replaces `FlushPageCallback`.
- A batch or run is converted at once, without 1024-row chunking, in the
  writers, the array index feed and BUILD INDEX; memory per batch is at most
  what the removed convertor held for one column of the block. CHAR is
  padded by the writers and by BUILD INDEX per batch through the CHAR
  layout; the `is_padded`/`pad_column` helpers are gone.
- `ArrayColumnWriter` checks the ANN item type at init, feeds an index only
  when it created its writer, and reuses its offsets buffer for `append_nulls`.

Rebased on apache#69221: the chunked `VariantSubcolumnWriter` flushes its value
chunks through `append_sparse_column`, the streaming root writer appends each
root batch as a column, and all-NULL ARRAY chunks keep taking the array path.

Preserve CHAR padding, key encoding, and on-disk page layouts. Update writer,
index, and storage-layout tests and adapt existing callers to the new APIs.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - ASAN BE build; BE UT: StorageLayoutTest, PageBuilderColumnTest,
      ColumnWriterStorageTest, PageFormatTest, ArrayIndexInputTest,
      IndexBuilderTest, AnnIndexWriterTest, InvertedIndexWriterTest,
      InvertedIndexArrayTest, CharTypePaddingTest, the variant writer/reader
      suites, and every suite of the test files that include the segment and
      column writers, the segment flusher format cases and the key coders
    - clang-format 16, build hygiene, and clang-tidy on changed lines
- Behavior changed: No; internal write-path refactoring
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>

…ockDataConvertor

### What problem does this PR solve?

Related PR: apache#68608, apache#68609, apache#68664, apache#69221

Problem Summary: Segment writing materializes block columns into intermediate
storage buffers through OlapBlockDataConvertor before feeding column writers,
indexes, and key encoders. Remove that intermediate converter and let these
consumers read column ranges directly through IColumn, row position, and count.

Share nullable-run processing, array index inputs, and StorageLayout conversion.
Encode keys from block columns and migrate partial-update, variant, and BUILD
INDEX paths. Keep page builders on one raw-byte add interface, with ColumnWriter
supplying physical fixed-width values or Slice descriptors and recording only
the rows accepted by each page.

The scalar writer follows the structure StarRocks' ScalarColumnWriter::_append
uses: a batch is first turned into contiguous storage cells, then one loop in
the base class splits the cells into NULL and value runs, feeds every run to
the page builder and the indexes, and flushes full pages.

- `StorageLayout<FT>::column_to_storage` has one signature for every type:
  `(column, row_pos, n, StorageBuffers&)`. It borrows the column's bytes when
  they are stored unchanged and otherwise fills the caller's `StorageBuffers`
  (converted bytes and Slice descriptors). Every row of the range is
  converted, NULL rows included, since no consumer reads a NULL row's cell.
  CHAR keeps a length-taking overload that pads and takes the null map: a
  NULL row can hold a value longer than the column, which must not be copied
  into its slot. BITMAP/HLL/QUANTILE_STATE serialise a whole batch the way the
  removed convertor did; AGG_STATE stores strings, bitmaps or fixed-length
  objects according to the column holding the states.
- `ScalarColumnWriter` is one concrete class again, constructed directly as on
  master: `append` peels the null map, `prepare_cells` turns the whole batch
  into cells through the StorageLayout of the column's type and rejects a
  batch before anything is written, and `append_values` is the single
  run/page loop that feeds the page builder, every index, the row ids and the
  null bits. The composite writers feed their null maps through
  `append_values` directly. The offset writer keeps master's
  `FlushPageCallback`; it only adds the `n + 1` offsets check and records the
  next item ordinal in `page_accepted`, where master's copy of the page loop
  did.
- A batch or run is converted at once, without 1024-row chunking, in the
  writers, the array index feed and BUILD INDEX; memory per batch is at most
  what the removed convertor held for one column of the block. CHAR is
  padded by the writers and by BUILD INDEX per batch through the CHAR
  layout; the `is_padded`/`pad_column` helpers are gone.
- `ArrayColumnWriter` checks the ANN item type at init, feeds an index only
  when it created its writer, and reuses its offsets buffer for `append_nulls`.

Rebased on apache#69221: the chunked `VariantSubcolumnWriter` flushes its value
chunks through `append_sparse_column`, the streaming root writer appends each
root batch as a column, and all-NULL ARRAY chunks keep taking the array path.

Preserve CHAR padding, key encoding, and on-disk page layouts. Update writer,
index, and storage-layout tests and adapt existing callers to the new APIs.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - ASAN BE build; BE UT: StorageLayoutTest, PageBuilderColumnTest,
      ColumnWriterStorageTest, PageFormatTest, ArrayIndexInputTest,
      IndexBuilderTest, AnnIndexWriterTest, InvertedIndexWriterTest,
      InvertedIndexArrayTest, CharTypePaddingTest, the variant writer/reader
      suites, and every suite of the test files that include the segment and
      column writers, the segment flusher format cases and the key coders
    - clang-format 16, build hygiene, and clang-tidy on changed lines
- Behavior changed: No; internal write-path refactoring
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>

…ockDataConvertor

### What problem does this PR solve?

Related PR: apache#68608, apache#68609, apache#68664, apache#69221

Problem Summary: Segment writing materializes block columns into intermediate
storage buffers through OlapBlockDataConvertor before feeding column writers,
indexes, and key encoders. Remove that intermediate converter and let these
consumers read column ranges directly through IColumn, row position, and count.

Share nullable-run processing, array index inputs, and StorageLayout conversion.
Encode keys from block columns and migrate partial-update, variant, and BUILD
INDEX paths. Keep page builders on one raw-byte add interface, with ColumnWriter
supplying physical fixed-width values or Slice descriptors and recording only
the rows accepted by each page.

The scalar writer keeps master's shape: a batch is cut into NULL runs and
value runs, and each value run is turned into contiguous storage cells and
written by one page loop in the base class, which feeds the page builder and
the indexes and flushes full pages.

- `StorageLayout<FT>::column_to_storage` has one signature for every type:
  `(column, row_pos, n, StorageBuffers&)`. It borrows the column's bytes when
  they are stored unchanged and otherwise fills the caller's `StorageBuffers`
  (converted bytes and Slice descriptors). Every row of the range is
  converted, and no layout takes a null map. CHAR keeps a length-taking
  overload that pads, which needs a range without NULL rows: a NULL row can
  hold a value longer than the column, which must not be copied into its
  slot. BITMAP/HLL/QUANTILE_STATE serialise a whole batch the way the removed
  convertor did. AGG_STATE's layout stores fixed-length objects; string and
  bitmap states go through the VARCHAR and BITMAP layouts, which
  `create_agg_state_writer` picks from the function's serialised type when it
  creates the writer, as master picked the convertor. A runtime
  `column_to_storage(type, ...)` maps a FieldType to its layout in one place
  for the writer, the array index feed and BUILD INDEX; it refuses CHAR, whose
  callers decide whether to pad.
- `ScalarColumnWriter` is one concrete class again, constructed directly as on
  master, and converts through the layout of its storage type: the column's
  type, or what an AGG_STATE function serialises to. `append` checks the
  whole batch for admission first, so a rejected
  batch writes nothing, then cuts it into NULL runs, written by
  `append_nulls`, and value runs, written by `append_values`: each value run
  is converted by `prepare_cells` and written by `append_data`, the single
  page loop that feeds the page builder, every index, the row ids and the null
  bits. NULL rows are never converted by the writer. The composite writers
  feed their null maps through `append_data`, as they did through master's
  `append_data`. The offset writer keeps master's `FlushPageCallback`; it only
  adds the `n + 1` offsets check and records the next item ordinal in
  `page_accepted`, where master's copy of the page loop did.
- Conversion has no 1024-row chunking: the writer converts each value run at
  once, and the array index feed and BUILD INDEX convert a batch of array rows
  or a run at once. The array index feed converts NULL elements too, as no
  index writer reads their cells, except CHAR: it pads only the runs of
  non-NULL elements, each into its own slots. BUILD INDEX pads CHAR per run
  for CLucene and BKD, and feeds it as it reads back to SNII.
- `ArrayColumnWriter` checks the ANN item type at init, feeds an index only
  when it created its writer, and reuses its offsets buffer for `append_nulls`.

Rebased on apache#69221: the chunked `VariantSubcolumnWriter` flushes its value
chunks through `append_sparse_column`, the streaming root writer appends each
root batch as a column, and all-NULL ARRAY chunks keep taking the array path.

Preserve CHAR padding, key encoding, and on-disk page layouts. Update writer,
index, and storage-layout tests and adapt existing callers to the new APIs.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - ASAN BE build; BE UT: StorageLayoutTest, PageBuilderColumnTest,
      ColumnWriterStorageTest, PageFormatTest, ArrayIndexInputTest,
      IndexBuilderTest, AnnIndexWriterTest, InvertedIndexWriterTest,
      InvertedIndexArrayTest, the variant writer/reader suites, and every
      suite of the test files that include the segment and column writers, the
      segment flusher format cases and the key coders
    - clang-format 16, build hygiene, and clang-tidy on the changed sources
- Behavior changed: No; internal write-path refactoring
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>

…ockDataConvertor

### What problem does this PR solve?

Related PR: apache#68608, apache#68609, apache#68664, apache#69221

Problem Summary: Segment writing materializes block columns into intermediate
storage buffers through OlapBlockDataConvertor before feeding column writers,
indexes, and key encoders. Remove that intermediate converter and let these
consumers read column ranges directly through IColumn, row position, and count.

Share nullable-run processing, array index inputs, and StorageLayout conversion.
Encode keys from block columns and migrate partial-update, variant, and BUILD
INDEX paths. Keep page builders on one raw-byte add interface, with ColumnWriter
supplying physical fixed-width values or Slice descriptors and recording only
the rows accepted by each page.

The scalar writer keeps master's shape: a batch is cut into NULL runs and
value runs, and each value run is turned into contiguous storage cells and
written by one page loop in the base class, which feeds the page builder and
the indexes and flushes full pages.

- `StorageLayout<FT>::column_to_storage` has one signature for every type:
  `(column, row_pos, n, StorageBuffers&)`. It borrows the column's bytes when
  they are stored unchanged and otherwise fills the caller's `StorageBuffers`
  (converted bytes and Slice descriptors). Every row of the range is
  converted, and no layout takes a null map. CHAR keeps a length-taking
  overload that pads, which needs a range without NULL rows: a NULL row can
  hold a value longer than the column, which must not be copied into its
  slot. BITMAP/HLL/QUANTILE_STATE serialise a whole batch the way the removed
  convertor did. AGG_STATE's layout stores fixed-length objects; string and
  bitmap states go through the VARCHAR and BITMAP layouts, which
  `create_agg_state_writer` picks from the function's serialised type when it
  creates the writer, as master picked the convertor. A runtime
  `column_to_storage(type, ...)` maps a FieldType to its layout in one place
  for the writer, the array index feed and BUILD INDEX; it refuses CHAR, whose
  callers decide whether to pad.
- `ScalarColumnWriter` is one concrete class again, constructed directly as on
  master, and converts through the layout of its storage type: the column's
  type, or what an AGG_STATE function serialises to. `append` checks the
  whole batch for admission first, so a rejected
  batch writes nothing, then cuts it into NULL runs, written by
  `append_nulls`, and value runs, written by `append_values`: each value run
  is converted by `prepare_cells` and written by `append_data`, the single
  page loop that feeds the page builder, every index, the row ids and the null
  bits. NULL rows are never converted by the writer. The composite writers
  feed their null maps through `append_data`, as they did through master's
  `append_data`. The offset writer keeps master's `FlushPageCallback` and its
  own copy of the page loop that records the next item ordinal; it only adds
  the `n + 1` offsets check.
- Conversion has no 1024-row chunking: the writer converts each value run at
  once, and the array index feed and BUILD INDEX convert a batch of array rows
  or a run at once. The array index feed converts NULL elements too, as no
  index writer reads their cells, except CHAR: it pads only the runs of
  non-NULL elements, each into its own slots. BUILD INDEX pads CHAR per run
  for CLucene and BKD, and feeds it as it reads back to SNII.
- `ArrayColumnWriter` checks the ANN item type at init, feeds an index only
  when it created its writer, and reuses its offsets buffer for `append_nulls`.

Rebased on apache#69221: the chunked `VariantSubcolumnWriter` flushes its value
chunks through `append_sparse_column`, the streaming root writer appends each
root batch as a column, and all-NULL ARRAY chunks keep taking the array path.

Preserve CHAR padding, key encoding, and on-disk page layouts. Update writer,
index, and storage-layout tests and adapt existing callers to the new APIs.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - ASAN BE build; BE UT: StorageLayoutTest, PageBuilderColumnTest,
      ColumnWriterStorageTest, PageFormatTest, ArrayIndexInputTest,
      IndexBuilderTest, AnnIndexWriterTest, InvertedIndexWriterTest,
      InvertedIndexArrayTest, the variant writer/reader suites, and every
      suite of the test files that include the segment and column writers, the
      segment flusher format cases and the key coders
    - clang-format 16, build hygiene, and clang-tidy on the changed sources
- Behavior changed: No; internal write-path refactoring
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>

…ockDataConvertor

### What problem does this PR solve?

Related PR: apache#68608, apache#68609, apache#68664, apache#69221

Problem Summary: Segment writing materializes block columns into intermediate
storage buffers through OlapBlockDataConvertor before feeding column writers,
indexes, and key encoders. Remove that intermediate converter and let these
consumers read column ranges directly through IColumn, row position, and count.

Share nullable-run processing, array index inputs, and StorageLayout conversion.
Encode keys from block columns and migrate partial-update, variant, and BUILD
INDEX paths. Keep page builders on one raw-byte add interface, with ColumnWriter
supplying physical fixed-width values or Slice descriptors and recording only
the rows accepted by each page.

The scalar writer keeps master's shape: a batch is cut into NULL runs and
value runs, and each value run is turned into contiguous storage cells and
written by one page loop in the base class, which feeds the page builder and
the indexes and flushes full pages.

- `StorageLayout<FT>::column_to_storage` has one signature for every type:
  `(column, row_pos, n, StorageBuffers&)`. It borrows the column's bytes when
  they are stored unchanged and otherwise fills the caller's `StorageBuffers`
  (converted bytes and Slice descriptors). Every row of the range is
  converted, and no layout takes a null map. CHAR keeps a length-taking
  overload that pads, which needs a range without NULL rows: a NULL row can
  hold a value longer than the column, which must not be copied into its
  slot. BITMAP/HLL/QUANTILE_STATE serialise a whole batch the way the removed
  convertor did. AGG_STATE's layout stores fixed-length objects; string and
  bitmap states go through the VARCHAR and BITMAP layouts, which
  `create_agg_state_writer` picks from the function's serialised type when it
  creates the writer, as master picked the convertor. A runtime
  `column_to_storage(type, ...)` maps a FieldType to its layout in one place
  for the writer, the array index feed and BUILD INDEX; it refuses CHAR, whose
  callers decide whether to pad.
- `ScalarColumnWriter` is one concrete class again, constructed directly as on
  master, and converts through the layout of its storage type: the column's
  type, or what an AGG_STATE function serialises to. `append` checks the
  whole batch for admission first, so a rejected
  batch writes nothing, then cuts it into NULL runs, written by
  `append_nulls`, and value runs, written by `append_values`: each value run
  is converted by `prepare_cells` and written by `append_data`, the single
  page loop that feeds the page builder, every index, the row ids and the null
  bits. NULL rows are never converted by the writer. The composite writers
  feed their null maps through `append_data`, as they did through master's
  `append_data`. The offset writer keeps master's `FlushPageCallback` and its
  own copy of the page loop that records the next item ordinal; it only adds
  the `n + 1` offsets check.
- Conversion has no 1024-row chunking: the writer converts each value run at
  once, and the array index feed and BUILD INDEX convert a batch of array rows
  or a run at once. The array index feed converts NULL elements too, as no
  index writer reads their cells, except CHAR: it pads only the runs of
  non-NULL elements, each into its own slots. BUILD INDEX pads CHAR per run
  for CLucene and BKD, and feeds it as it reads back to SNII.
- `ArrayColumnWriter` checks the ANN item type at init, feeds an index only
  when it created its writer, and reuses its offsets buffer for `append_nulls`.

Rebased on apache#69221: the chunked `VariantSubcolumnWriter` flushes its value
chunks through `append_sparse_column`, the streaming root writer appends each
root batch as a column, and all-NULL ARRAY chunks keep taking the array path.

Preserve CHAR padding, key encoding, and on-disk page layouts. Update writer,
index, and storage-layout tests and adapt existing callers to the new APIs.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - ASAN BE build; BE UT: StorageLayoutTest, PageBuilderColumnTest,
      ColumnWriterStorageTest, PageFormatTest, ArrayIndexInputTest,
      IndexBuilderTest, AnnIndexWriterTest, InvertedIndexWriterTest,
      InvertedIndexArrayTest, the variant writer/reader suites, and every
      suite of the test files that include the segment and column writers, the
      segment flusher format cases and the key coders
    - clang-format 16, build hygiene, and clang-tidy on the changed sources
- Behavior changed: No; internal write-path refactoring
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>

…ockDataConvertor

### What problem does this PR solve?

Related PR: apache#68608, apache#68609, apache#68664, apache#69221

Problem Summary: Segment writing materializes block columns into intermediate
storage buffers through OlapBlockDataConvertor before feeding column writers,
indexes, and key encoders. Remove that intermediate converter and let these
consumers read column ranges directly through IColumn, row position, and count.

Share nullable-run processing, array index inputs, and StorageLayout conversion.
Encode keys from block columns and migrate partial-update, variant, and BUILD
INDEX paths. Keep page builders on one raw-byte add interface, with ColumnWriter
supplying physical fixed-width values or Slice descriptors and recording only
the rows accepted by each page.

The scalar writer keeps master's shape: a batch is cut into NULL runs and
value runs, and each value run is turned into contiguous storage cells and
written by one page loop in the base class, which feeds the page builder and
the indexes and flushes full pages.

- `StorageLayout<FT>::column_to_storage` has one signature for every type:
  `(column, row_pos, n, StorageBuffers&)`. It borrows the column's bytes when
  they are stored unchanged and otherwise fills the caller's `StorageBuffers`
  (converted bytes and Slice descriptors). Every row of the range is
  converted, and no layout takes a null map. CHAR keeps a length-taking
  overload that pads, which needs a range without NULL rows: a NULL row can
  hold a value longer than the column, which must not be copied into its
  slot. BITMAP/HLL/QUANTILE_STATE serialise a whole batch the way the removed
  convertor did. AGG_STATE's layout stores fixed-length objects; string and
  bitmap states go through the VARCHAR and BITMAP layouts, which
  `create_agg_state_writer` picks from the function's serialised type when it
  creates the writer, as master picked the convertor. A runtime
  `column_to_storage(type, ...)` maps a FieldType to its layout in one place
  for the writer, the array index feed and BUILD INDEX; it refuses CHAR, whose
  callers decide whether to pad.
- `ScalarColumnWriter` is one concrete class again, constructed directly as on
  master, and converts through the layout of its storage type: the column's
  type, or what an AGG_STATE function serialises to. `append` checks the
  whole batch for admission first, so a rejected
  batch writes nothing, then cuts it into NULL runs, written by
  `append_nulls`, and value runs, written by `append_values`: each value run
  is converted by `prepare_cells` and written by `append_data`, the single
  page loop that feeds the page builder, every index, the row ids and the null
  bits. NULL rows are never converted by the writer. The composite writers
  feed their null maps through `append_data`, as they did through master's
  `append_data`. The offset writer keeps master's `FlushPageCallback` and its
  own copy of the page loop that records the next item ordinal; it only adds
  the `n + 1` offsets check.
- Conversion has no 1024-row chunking: the writer converts each value run at
  once, and the array index feed and BUILD INDEX convert a batch of array rows
  or a run at once. The array index feed converts NULL elements too, as no
  index writer reads their cells, except CHAR: it pads only the runs of
  non-NULL elements, each into its own slots. BUILD INDEX pads CHAR per run
  for CLucene and BKD, and feeds it as it reads back to SNII.
- `ArrayColumnWriter` checks the ANN item type at init, feeds an index only
  when it created its writer, and reuses its offsets buffer for `append_nulls`.

Rebased on apache#69221: the chunked `VariantSubcolumnWriter` flushes its value
chunks through `append_sparse_column`, the streaming root writer appends each
root batch as a column, and all-NULL ARRAY chunks keep taking the array path.

Preserve CHAR padding, key encoding, and on-disk page layouts. Update writer,
index, and storage-layout tests and adapt existing callers to the new APIs.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - ASAN BE build; BE UT: StorageLayoutTest, PageBuilderColumnTest,
      ColumnWriterStorageTest, PageFormatTest, ArrayIndexInputTest,
      IndexBuilderTest, AnnIndexWriterTest, InvertedIndexWriterTest,
      InvertedIndexArrayTest, the variant writer/reader suites, and every
      suite of the test files that include the segment and column writers, the
      segment flusher format cases and the key coders
    - clang-format 16, build hygiene, and clang-tidy on the changed sources
- Behavior changed: No; internal write-path refactoring
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>

…ockDataConvertor

Related PR: apache#68608, apache#68609, apache#68664, apache#69221

Problem Summary: Segment writing materializes block columns into intermediate
storage buffers through OlapBlockDataConvertor before feeding column writers,
indexes, and key encoders. Remove that intermediate converter and let these
consumers read column ranges directly through IColumn, row position, and count.

Share nullable-run processing, array index inputs, and StorageLayout conversion.
Encode keys from block columns and migrate partial-update, variant, and BUILD
INDEX paths. Keep page builders on one raw-byte add interface, with ColumnWriter
supplying physical fixed-width values or Slice descriptors and recording only
the rows accepted by each page.

The scalar writer keeps master's shape: a batch is cut into NULL runs and
value runs, and each value run is turned into contiguous storage cells and
written by one page loop in the base class, which feeds the page builder and
the indexes and flushes full pages.

- `StorageLayout<FT>::column_to_storage` has one signature for every type:
  `(column, row_pos, n, StorageBuffers&)`. It borrows the column's bytes when
  they are stored unchanged and otherwise fills the caller's `StorageBuffers`
  (converted bytes and Slice descriptors). Every row of the range is
  converted, and no layout takes a null map. CHAR keeps a length-taking
  overload that pads, which needs a range without NULL rows: a NULL row can
  hold a value longer than the column, which must not be copied into its
  slot. BITMAP/HLL/QUANTILE_STATE serialise a whole batch the way the removed
  convertor did. AGG_STATE's layout stores fixed-length objects; string and
  bitmap states go through the VARCHAR and BITMAP layouts, which
  `create_agg_state_writer` picks from the function's serialised type when it
  creates the writer, as master picked the convertor. A runtime
  `column_to_storage(type, ...)` maps a FieldType to its layout in one place
  for the writer, the array index feed and BUILD INDEX; it refuses CHAR, whose
  callers decide whether to pad.
- `ScalarColumnWriter` is one concrete class again, constructed directly as on
  master, and converts through the layout of its storage type: the column's
  type, or what an AGG_STATE function serialises to. `append` checks the
  whole batch for admission first, so a rejected
  batch writes nothing, then cuts it into NULL runs, written by
  `append_nulls`, and value runs, written by `append_values`: each value run
  is converted by `prepare_cells` and written by `append_data`, the single
  page loop that feeds the page builder, every index, the row ids and the null
  bits. NULL rows are never converted by the writer. The composite writers
  feed their null maps through `append_data`, as they did through master's
  `append_data`. The offset writer keeps master's `FlushPageCallback` and its
  own copy of the page loop that records the next item ordinal; it only adds
  the `n + 1` offsets check.
- Conversion has no 1024-row chunking: the writer converts each value run at
  once, and the array index feed and BUILD INDEX convert a batch of array rows
  or a run at once. The array index feed converts NULL elements too, as no
  index writer reads their cells, except CHAR: it pads only the runs of
  non-NULL elements, each into its own slots. BUILD INDEX pads CHAR per run
  for CLucene and BKD, and feeds it as it reads back to SNII.
- `ArrayColumnWriter` checks the ANN item type at init, feeds an index only
  when it created its writer, and reuses its offsets buffer for `append_nulls`.

Rebased on apache#69221: the chunked `VariantSubcolumnWriter` flushes its value
chunks through `append_sparse_column`, the streaming root writer appends each
root batch as a column, and all-NULL ARRAY chunks keep taking the array path.

Preserve CHAR padding, key encoding, and on-disk page layouts. Update writer,
index, and storage-layout tests and adapt existing callers to the new APIs.

None

- Test: Unit Test
    - ASAN BE build; BE UT: StorageLayoutTest, PageBuilderColumnTest,
      ColumnWriterStorageTest, PageFormatTest, ArrayIndexInputTest,
      IndexBuilderTest, AnnIndexWriterTest, InvertedIndexWriterTest,
      InvertedIndexArrayTest, the variant writer/reader suites, and every
      suite of the test files that include the segment and column writers, the
      segment flusher format cases and the key coders
    - clang-format 16, build hygiene, and clang-tidy on the changed sources
- Behavior changed: No; internal write-path refactoring
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>

…ockDataConvertor

Related PR: apache#68608, apache#68609, apache#68664, apache#69221

Problem Summary: Segment writing materializes block columns into intermediate
storage buffers through OlapBlockDataConvertor before feeding column writers,
indexes, and key encoders. Remove that intermediate converter and let these
consumers read column ranges directly through IColumn, row position, and count.

Share nullable-run processing, array index inputs, and StorageLayout conversion.
Encode keys from block columns and migrate partial-update, variant, and BUILD
INDEX paths. Keep page builders on one raw-byte add interface, with ColumnWriter
supplying physical fixed-width values or Slice descriptors and recording only
the rows accepted by each page.

The scalar writer keeps master's shape: a batch is cut into NULL runs and
value runs, and each value run is turned into contiguous storage cells and
written by one page loop in the base class, which feeds the page builder and
the indexes and flushes full pages.

- `StorageLayout<FT>::column_to_storage` has one signature for every type:
  `(column, row_pos, n, StorageBuffers&)`. It borrows the column's bytes when
  they are stored unchanged and otherwise fills the caller's `StorageBuffers`
  (converted bytes and Slice descriptors). Every row of the range is
  converted, and no layout takes a null map. CHAR keeps a length-taking
  overload that pads, which needs a range without NULL rows: a NULL row can
  hold a value longer than the column, which must not be copied into its
  slot. BITMAP/HLL/QUANTILE_STATE serialise a whole batch the way the removed
  convertor did. AGG_STATE's layout stores fixed-length objects; string and
  bitmap states go through the VARCHAR and BITMAP layouts, which
  `create_agg_state_writer` picks from the function's serialised type when it
  creates the writer, as master picked the convertor. A runtime
  `column_to_storage(type, ...)` maps a FieldType to its layout in one place
  for the writer, the array index feed and BUILD INDEX; it refuses CHAR, whose
  callers decide whether to pad.
- `ScalarColumnWriter` is one concrete class again, constructed directly as on
  master, and converts through the layout of its storage type: the column's
  type, or what an AGG_STATE function serialises to. `append` checks the
  whole batch for admission first, so a rejected
  batch writes nothing, then cuts it into NULL runs, written by
  `append_nulls`, and value runs, written by `append_values`: each value run
  is converted by `prepare_cells` and written by `append_data`, the single
  page loop that feeds the page builder, every index, the row ids and the null
  bits. NULL rows are never converted by the writer. The composite writers
  feed their null maps through `append_data`, as they did through master's
  `append_data`. The offset writer keeps master's `FlushPageCallback` and its
  own copy of the page loop that records the next item ordinal; it only adds
  the `n + 1` offsets check.
- Conversion has no 1024-row chunking: the writer converts each value run at
  once, and the array index feed and BUILD INDEX convert a batch of array rows
  or a run at once. The array index feed converts NULL elements too, as no
  index writer reads their cells, except CHAR: it pads only the runs of
  non-NULL elements, each into its own slots. BUILD INDEX pads CHAR per run
  for CLucene and BKD, and feeds it as it reads back to SNII.
- `ArrayColumnWriter` checks the ANN item type at init, feeds an index only
  when it created its writer, and reuses its offsets buffer for `append_nulls`.

Rebased on apache#69221: the chunked `VariantSubcolumnWriter` flushes its value
chunks through `append_sparse_column`, the streaming root writer appends each
root batch as a column, and all-NULL ARRAY chunks keep taking the array path.

Preserve CHAR padding, key encoding, and on-disk page layouts. Update writer,
index, and storage-layout tests and adapt existing callers to the new APIs.

None

- Test: Unit Test
    - ASAN BE build; BE UT: StorageLayoutTest, PageBuilderColumnTest,
      ColumnWriterStorageTest, PageFormatTest, ArrayIndexInputTest,
      IndexBuilderTest, AnnIndexWriterTest, InvertedIndexWriterTest,
      InvertedIndexArrayTest, the variant writer/reader suites, and every
      suite of the test files that include the segment and column writers, the
      segment flusher format cases and the key coders
    - clang-format 16, build hygiene, and clang-tidy on the changed sources
- Behavior changed: No; internal write-path refactoring
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>

…ockDataConvertor (#69070)

Related PR: #68608, #68609, #68664

This PR removes OlapBlockDataConvertor and changes the write path to
consume column ranges directly through `(const IColumn&, row_pos,
num_rows)`.

- Extend StorageLayout to provide column-to-storage conversion and
object serialization.
- Update column writers to consume IColumn directly.
- Encode keys directly from block columns and migrate partial-update,
variant and BUILD INDEX paths.
- Existing CHAR padding, key encoding and on-disk page formats are
preserved.