/root/doris/be/src/olap/schema.cpp

Source
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#include "olap/schema.h"

#include <glog/logging.h>

#include <boost/iterator/iterator_facade.hpp>
#include <ostream>
#include <unordered_set>
#include <utility>

#include "common/config.h"
#include "olap/olap_common.h"
#include "runtime/define_primitive_type.h"
#include "util/trace.h"
#include "vec/columns/column_array.h"
#include "vec/columns/column_dictionary.h"
#include "vec/columns/column_map.h"
#include "vec/columns/column_nullable.h"
#include "vec/columns/column_struct.h"
#include "vec/columns/predicate_column.h"
#include "vec/core/types.h"
#include "vec/data_types/data_type.h"
#include "vec/data_types/data_type_factory.hpp"

namespace doris {

Schema::Schema(const Schema& other) {
    _copy_from(other);
}

Schema& Schema::operator=(const Schema& other) {
    if (this != &other) {
        _copy_from(other);
    }
    return *this;
}

void Schema::_copy_from(const Schema& other) {
    _col_ids = other._col_ids;
    _col_offsets = other._col_offsets;

    _num_key_columns = other._num_key_columns;
    _schema_size = other._schema_size;

    // Deep copy _cols
    // TODO(lingbin): really need clone?
    _cols.resize(other._cols.size(), nullptr);
    for (auto cid : _col_ids) {
        _cols[cid] = other._cols[cid]->clone();
    }
}

void Schema::_init(const std::vector<TabletColumnPtr>& cols, const std::vector<ColumnId>& col_ids,
                   size_t num_key_columns) {
    _col_ids = col_ids;
    _num_key_columns = num_key_columns;

    _cols.resize(cols.size(), nullptr);
    _col_offsets.resize(_cols.size(), -1);

    size_t offset = 0;
    std::unordered_set<uint32_t> col_id_set(col_ids.begin(), col_ids.end());
    for (int cid = 0; cid < cols.size(); ++cid) {
        if (col_id_set.find(cid) == col_id_set.end()) {
            continue;
        }
        _cols[cid] = FieldFactory::create(*cols[cid]);

        _col_offsets[cid] = offset;
        // Plus 1 byte for null byte
        offset += _cols[cid]->size() + 1;
    }

    _schema_size = offset;
}

void Schema::_init(const std::vector<const Field*>& cols, const std::vector<ColumnId>& col_ids,
                   size_t num_key_columns) {
    _col_ids = col_ids;
    _num_key_columns = num_key_columns;

    _cols.resize(cols.size(), nullptr);
    _col_offsets.resize(_cols.size(), -1);

    size_t offset = 0;
    std::unordered_set<uint32_t> col_id_set(col_ids.begin(), col_ids.end());
    for (int cid = 0; cid < cols.size(); ++cid) {
        if (col_id_set.find(cid) == col_id_set.end()) {
            continue;
        }
        // TODO(lingbin): is it necessary to clone Field? each SegmentIterator will
        // use this func, can we avoid clone?
        _cols[cid] = cols[cid]->clone();

        _col_offsets[cid] = offset;
        // Plus 1 byte for null byte
        offset += _cols[cid]->size() + 1;
    }

    _schema_size = offset;
}

Schema::~Schema() {
    for (auto col : _cols) {
        delete col;
    }
}

vectorized::DataTypePtr Schema::get_data_type_ptr(const Field& field) {
    return vectorized::DataTypeFactory::instance().create_data_type(field);
}

vectorized::IColumn::MutablePtr Schema::get_column_by_field(const Field& field) {
    return get_data_type_ptr(field)->create_column();
}

vectorized::IColumn::MutablePtr Schema::get_predicate_column_ptr(const FieldType& type,
                                                                 bool is_nullable,
                                                                 const ReaderType reader_type) {
    vectorized::IColumn::MutablePtr ptr = nullptr;
    switch (type) {
    case FieldType::OLAP_FIELD_TYPE_BOOL:
        ptr = doris::vectorized::PredicateColumnType<TYPE_BOOLEAN>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_TINYINT:
        ptr = doris::vectorized::PredicateColumnType<TYPE_TINYINT>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_SMALLINT:
        ptr = doris::vectorized::PredicateColumnType<TYPE_SMALLINT>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_INT:
        ptr = doris::vectorized::PredicateColumnType<TYPE_INT>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_FLOAT:
        ptr = doris::vectorized::PredicateColumnType<TYPE_FLOAT>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_DOUBLE:
        ptr = doris::vectorized::PredicateColumnType<TYPE_DOUBLE>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_BIGINT:
        ptr = doris::vectorized::PredicateColumnType<TYPE_BIGINT>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_LARGEINT:
        ptr = doris::vectorized::PredicateColumnType<TYPE_LARGEINT>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_DATE:
        ptr = doris::vectorized::PredicateColumnType<TYPE_DATE>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_DATEV2:
        ptr = doris::vectorized::PredicateColumnType<TYPE_DATEV2>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_DATETIMEV2:
        ptr = doris::vectorized::PredicateColumnType<TYPE_DATETIMEV2>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_DATETIME:
        ptr = doris::vectorized::PredicateColumnType<TYPE_DATETIME>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_TIMESTAMPTZ:
        ptr = doris::vectorized::PredicateColumnType<TYPE_TIMESTAMPTZ>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_CHAR:
        if (config::enable_low_cardinality_optimize && reader_type == ReaderType::READER_QUERY) {
            ptr = doris::vectorized::ColumnDictI32::create(type);
        } else {
            ptr = doris::vectorized::PredicateColumnType<TYPE_CHAR>::create();
        }
        break;
    case FieldType::OLAP_FIELD_TYPE_VARCHAR:
    case FieldType::OLAP_FIELD_TYPE_STRING:
    case FieldType::OLAP_FIELD_TYPE_JSONB:
        if (config::enable_low_cardinality_optimize && reader_type == ReaderType::READER_QUERY) {
            ptr = doris::vectorized::ColumnDictI32::create(type);
        } else {
            ptr = doris::vectorized::PredicateColumnType<TYPE_STRING>::create();
        }
        break;
    case FieldType::OLAP_FIELD_TYPE_DECIMAL:
        ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMALV2>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
        ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL32>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
        ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL64>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
        ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL128I>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_DECIMAL256:
        ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL256>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_IPV4:
        ptr = doris::vectorized::PredicateColumnType<TYPE_IPV4>::create();
        break;
    case FieldType::OLAP_FIELD_TYPE_IPV6:
        ptr = doris::vectorized::PredicateColumnType<TYPE_IPV6>::create();
        break;
    default:
        throw Exception(
                ErrorCode::SCHEMA_SCHEMA_FIELD_INVALID,
                fmt::format("Unexpected type when choosing predicate column, type={}", int(type)));
    }

    if (is_nullable) {
        return doris::vectorized::ColumnNullable::create(std::move(ptr),
                                                         doris::vectorized::ColumnUInt8::create());
    }
    return ptr;
}

} // namespace doris

Coverage Report

Created: 2026-01-06 18:48

Line	Count	Source
1		// Licensed to the Apache Software Foundation (ASF) under one
2		// or more contributor license agreements. See the NOTICE file
3		// distributed with this work for additional information
4		// regarding copyright ownership. The ASF licenses this file
5		// to you under the Apache License, Version 2.0 (the
6		// "License"); you may not use this file except in compliance
7		// with the License. You may obtain a copy of the License at
8		//
9		// http://www.apache.org/licenses/LICENSE-2.0
10		//
11		// Unless required by applicable law or agreed to in writing,
12		// software distributed under the License is distributed on an
13		// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14		// KIND, either express or implied. See the License for the
15		// specific language governing permissions and limitations
16		// under the License.
17
18		#include "olap/schema.h"
19
20		#include <glog/logging.h>
21
22		#include <boost/iterator/iterator_facade.hpp>
23		#include <ostream>
24		#include <unordered_set>
25		#include <utility>
26
27		#include "common/config.h"
28		#include "olap/olap_common.h"
29		#include "runtime/define_primitive_type.h"
30		#include "util/trace.h"
31		#include "vec/columns/column_array.h"
32		#include "vec/columns/column_dictionary.h"
33		#include "vec/columns/column_map.h"
34		#include "vec/columns/column_nullable.h"
35		#include "vec/columns/column_struct.h"
36		#include "vec/columns/predicate_column.h"
37		#include "vec/core/types.h"
38		#include "vec/data_types/data_type.h"
39		#include "vec/data_types/data_type_factory.hpp"
40
41		namespace doris {
42
43	5.04M	Schema::Schema(const Schema& other) {
44	5.04M	_copy_from(other);
45	5.04M	}
46
47	0	Schema& Schema::operator=(const Schema& other) {
48	0	if (this != &other) {
49	0	_copy_from(other);
50	0	}
51	0	return *this;
52	0	}
53
54	5.08M	void Schema::_copy_from(const Schema& other) {
55	5.08M	_col_ids = other._col_ids;
56	5.08M	_col_offsets = other._col_offsets;
57
58	5.08M	_num_key_columns = other._num_key_columns;
59	5.08M	_schema_size = other._schema_size;
60
61		// Deep copy _cols
62		// TODO(lingbin): really need clone?
63	5.08M	_cols.resize(other._cols.size(), nullptr);
64	7.67M	for (auto cid : _col_ids) {
65	7.67M	_cols[cid] = other._cols[cid]->clone();
66	7.67M	}
67	5.08M	}
68
69		void Schema::_init(const std::vector<TabletColumnPtr>& cols, const std::vector<ColumnId>& col_ids,
70	7.50M	size_t num_key_columns) {
71	7.50M	_col_ids = col_ids;
72	7.50M	_num_key_columns = num_key_columns;
73
74	7.50M	_cols.resize(cols.size(), nullptr);
75	7.50M	_col_offsets.resize(_cols.size(), -1);
76
77	7.50M	size_t offset = 0;
78	7.50M	std::unordered_set<uint32_t> col_id_set(col_ids.begin(), col_ids.end());
79	113M	for (int cid = 0; cid < cols.size(); ++cid) {
80	105M	if (col_id_set.find(cid) == col_id_set.end()) {
81	62.8M	continue;
82	62.8M	}
83	42.9M	_cols[cid] = FieldFactory::create(*cols[cid]);
84
85	42.9M	_col_offsets[cid] = offset;
86		// Plus 1 byte for null byte
87	42.9M	offset += _cols[cid]->size() + 1;
88	42.9M	}
89
90	7.50M	_schema_size = offset;
91	7.50M	}
92
93		void Schema::_init(const std::vector<const Field*>& cols, const std::vector<ColumnId>& col_ids,
94	1.45M	size_t num_key_columns) {
95	1.45M	_col_ids = col_ids;
96	1.45M	_num_key_columns = num_key_columns;
97
98	1.45M	_cols.resize(cols.size(), nullptr);
99	1.45M	_col_offsets.resize(_cols.size(), -1);
100
101	1.45M	size_t offset = 0;
102	1.45M	std::unordered_set<uint32_t> col_id_set(col_ids.begin(), col_ids.end());
103	6.64M	for (int cid = 0; cid < cols.size(); ++cid) {
104	5.18M	if (col_id_set.find(cid) == col_id_set.end()) {
105	0	continue;
106	0	}
107		// TODO(lingbin): is it necessary to clone Field? each SegmentIterator will
108		// use this func, can we avoid clone?
109	5.18M	_cols[cid] = cols[cid]->clone();
110
111	5.18M	_col_offsets[cid] = offset;
112		// Plus 1 byte for null byte
113	5.18M	offset += _cols[cid]->size() + 1;
114	5.18M	}
115
116	1.45M	_schema_size = offset;
117	1.45M	}
118
119	14.0M	Schema::~Schema() {
120	174M	for (auto col : _cols) {
121	174M	delete col;
122	174M	}
123	14.0M	}
124
125	52.7M	vectorized::DataTypePtr Schema::get_data_type_ptr(const Field& field) {
126	52.7M	return vectorized::DataTypeFactory::instance().create_data_type(field);
127	52.7M	}
128
129	5.35M	vectorized::IColumn::MutablePtr Schema::get_column_by_field(const Field& field) {
130	5.35M	return get_data_type_ptr(field)->create_column();
131	5.35M	}
132
133		vectorized::IColumn::MutablePtr Schema::get_predicate_column_ptr(const FieldType& type,
134		bool is_nullable,
135	1.40M	const ReaderType reader_type) {
136	1.40M	vectorized::IColumn::MutablePtr ptr = nullptr;
137	1.40M	switch (type) {
138	328	case FieldType::OLAP_FIELD_TYPE_BOOL:
139	328	ptr = doris::vectorized::PredicateColumnType<TYPE_BOOLEAN>::create();
140	328	break;
141	1.36M	case FieldType::OLAP_FIELD_TYPE_TINYINT:
142	1.36M	ptr = doris::vectorized::PredicateColumnType<TYPE_TINYINT>::create();
143	1.36M	break;
144	682	case FieldType::OLAP_FIELD_TYPE_SMALLINT:
145	682	ptr = doris::vectorized::PredicateColumnType<TYPE_SMALLINT>::create();
146	682	break;
147	13.8k	case FieldType::OLAP_FIELD_TYPE_INT:
148	13.8k	ptr = doris::vectorized::PredicateColumnType<TYPE_INT>::create();
149	13.8k	break;
150	25	case FieldType::OLAP_FIELD_TYPE_FLOAT:
151	25	ptr = doris::vectorized::PredicateColumnType<TYPE_FLOAT>::create();
152	25	break;
153	116	case FieldType::OLAP_FIELD_TYPE_DOUBLE:
154	116	ptr = doris::vectorized::PredicateColumnType<TYPE_DOUBLE>::create();
155	116	break;
156	1.07k	case FieldType::OLAP_FIELD_TYPE_BIGINT:
157	1.07k	ptr = doris::vectorized::PredicateColumnType<TYPE_BIGINT>::create();
158	1.07k	break;
159	598	case FieldType::OLAP_FIELD_TYPE_LARGEINT:
160	598	ptr = doris::vectorized::PredicateColumnType<TYPE_LARGEINT>::create();
161	598	break;
162	287	case FieldType::OLAP_FIELD_TYPE_DATE:
163	287	ptr = doris::vectorized::PredicateColumnType<TYPE_DATE>::create();
164	287	break;
165	3.34k	case FieldType::OLAP_FIELD_TYPE_DATEV2:
166	3.34k	ptr = doris::vectorized::PredicateColumnType<TYPE_DATEV2>::create();
167	3.34k	break;
168	584	case FieldType::OLAP_FIELD_TYPE_DATETIMEV2:
169	584	ptr = doris::vectorized::PredicateColumnType<TYPE_DATETIMEV2>::create();
170	584	break;
171	438	case FieldType::OLAP_FIELD_TYPE_DATETIME:
172	438	ptr = doris::vectorized::PredicateColumnType<TYPE_DATETIME>::create();
173	438	break;
174	3.59k	case FieldType::OLAP_FIELD_TYPE_TIMESTAMPTZ:
175	3.59k	ptr = doris::vectorized::PredicateColumnType<TYPE_TIMESTAMPTZ>::create();
176	3.59k	break;
177	1.15k	case FieldType::OLAP_FIELD_TYPE_CHAR:
178	1.15k	if (config::enable_low_cardinality_optimize && reader_type == ReaderType::READER_QUERY) {
179	1.14k	ptr = doris::vectorized::ColumnDictI32::create(type);
180	1.14k	} else {
181	5	ptr = doris::vectorized::PredicateColumnType<TYPE_CHAR>::create();
182	5	}
183	1.15k	break;
184	0	case FieldType::OLAP_FIELD_TYPE_VARCHAR:
185	12.3k	case FieldType::OLAP_FIELD_TYPE_STRING:
186	12.4k	case FieldType::OLAP_FIELD_TYPE_JSONB:
187	12.4k	if (config::enable_low_cardinality_optimize && reader_type == ReaderType::READER_QUERY) {
188	12.0k	ptr = doris::vectorized::ColumnDictI32::create(type);
189	12.0k	} else {
190	372	ptr = doris::vectorized::PredicateColumnType<TYPE_STRING>::create();
191	372	}
192	12.4k	break;
193	5	case FieldType::OLAP_FIELD_TYPE_DECIMAL:
194	5	ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMALV2>::create();
195	5	break;
196	96	case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
197	96	ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL32>::create();
198	96	break;
199	234	case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
200	234	ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL64>::create();
201	234	break;
202	839	case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
203	839	ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL128I>::create();
204	839	break;
205	180	case FieldType::OLAP_FIELD_TYPE_DECIMAL256:
206	180	ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL256>::create();
207	180	break;
208	78	case FieldType::OLAP_FIELD_TYPE_IPV4:
209	78	ptr = doris::vectorized::PredicateColumnType<TYPE_IPV4>::create();
210	78	break;
211	87	case FieldType::OLAP_FIELD_TYPE_IPV6:
212	87	ptr = doris::vectorized::PredicateColumnType<TYPE_IPV6>::create();
213	87	break;
214	0	default:
215	0	throw Exception(
216	0	ErrorCode::SCHEMA_SCHEMA_FIELD_INVALID,
217	0	fmt::format("Unexpected type when choosing predicate column, type={}", int(type)));
218	1.40M	}
219
220	1.40M	if (is_nullable) {
221	20.5k	return doris::vectorized::ColumnNullable::create(std::move(ptr),
222	20.5k	doris::vectorized::ColumnUInt8::create());
223	20.5k	}
224	1.38M	return ptr;
225	1.40M	}
226
227		} // namespace doris