/root/doris/be/src/exec/schema_scanner.cpp
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 "exec/schema_scanner.h" |
19 | | |
20 | | #include <gen_cpp/Descriptors_types.h> |
21 | | #include <gen_cpp/Types_types.h> |
22 | | #include <glog/logging.h> |
23 | | #include <string.h> |
24 | | |
25 | | #include <new> |
26 | | #include <ostream> |
27 | | #include <utility> |
28 | | |
29 | | #include "exec/schema_scanner/schema_active_queries_scanner.h" |
30 | | #include "exec/schema_scanner/schema_backend_active_tasks.h" |
31 | | #include "exec/schema_scanner/schema_backend_configuration_scanner.h" |
32 | | #include "exec/schema_scanner/schema_backend_kerberos_ticket_cache.h" |
33 | | #include "exec/schema_scanner/schema_catalog_meta_cache_stats_scanner.h" |
34 | | #include "exec/schema_scanner/schema_charsets_scanner.h" |
35 | | #include "exec/schema_scanner/schema_cluster_snapshot_properties_scanner.h" |
36 | | #include "exec/schema_scanner/schema_cluster_snapshots_scanner.h" |
37 | | #include "exec/schema_scanner/schema_collations_scanner.h" |
38 | | #include "exec/schema_scanner/schema_column_data_sizes_scanner.h" |
39 | | #include "exec/schema_scanner/schema_columns_scanner.h" |
40 | | #include "exec/schema_scanner/schema_dummy_scanner.h" |
41 | | #include "exec/schema_scanner/schema_encryption_keys_scanner.h" |
42 | | #include "exec/schema_scanner/schema_file_cache_statistics.h" |
43 | | #include "exec/schema_scanner/schema_files_scanner.h" |
44 | | #include "exec/schema_scanner/schema_metadata_name_ids_scanner.h" |
45 | | #include "exec/schema_scanner/schema_partitions_scanner.h" |
46 | | #include "exec/schema_scanner/schema_processlist_scanner.h" |
47 | | #include "exec/schema_scanner/schema_profiling_scanner.h" |
48 | | #include "exec/schema_scanner/schema_routine_load_job_scanner.h" |
49 | | #include "exec/schema_scanner/schema_routine_scanner.h" |
50 | | #include "exec/schema_scanner/schema_rowsets_scanner.h" |
51 | | #include "exec/schema_scanner/schema_schema_privileges_scanner.h" |
52 | | #include "exec/schema_scanner/schema_schemata_scanner.h" |
53 | | #include "exec/schema_scanner/schema_sql_block_rule_status_scanner.h" |
54 | | #include "exec/schema_scanner/schema_table_options_scanner.h" |
55 | | #include "exec/schema_scanner/schema_table_privileges_scanner.h" |
56 | | #include "exec/schema_scanner/schema_table_properties_scanner.h" |
57 | | #include "exec/schema_scanner/schema_tables_scanner.h" |
58 | | #include "exec/schema_scanner/schema_tablets_scanner.h" |
59 | | #include "exec/schema_scanner/schema_user_privileges_scanner.h" |
60 | | #include "exec/schema_scanner/schema_user_scanner.h" |
61 | | #include "exec/schema_scanner/schema_variables_scanner.h" |
62 | | #include "exec/schema_scanner/schema_view_dependency_scanner.h" |
63 | | #include "exec/schema_scanner/schema_views_scanner.h" |
64 | | #include "exec/schema_scanner/schema_workload_group_privileges.h" |
65 | | #include "exec/schema_scanner/schema_workload_group_resource_usage_scanner.h" |
66 | | #include "exec/schema_scanner/schema_workload_groups_scanner.h" |
67 | | #include "exec/schema_scanner/schema_workload_sched_policy_scanner.h" |
68 | | #include "olap/hll.h" |
69 | | #include "pipeline/dependency.h" |
70 | | #include "runtime/define_primitive_type.h" |
71 | | #include "runtime/fragment_mgr.h" |
72 | | #include "runtime/types.h" |
73 | | #include "util/string_util.h" |
74 | | #include "util/types.h" |
75 | | #include "vec/columns/column.h" |
76 | | #include "vec/columns/column_complex.h" |
77 | | #include "vec/columns/column_nullable.h" |
78 | | #include "vec/columns/column_string.h" |
79 | | #include "vec/columns/column_vector.h" |
80 | | #include "vec/common/string_ref.h" |
81 | | #include "vec/core/block.h" |
82 | | #include "vec/core/column_with_type_and_name.h" |
83 | | #include "vec/core/types.h" |
84 | | #include "vec/data_types/data_type.h" |
85 | | #include "vec/data_types/data_type_factory.hpp" |
86 | | |
87 | | namespace doris { |
88 | | class ObjectPool; |
89 | | |
90 | | SchemaScanner::SchemaScanner(const std::vector<ColumnDesc>& columns, TSchemaTableType::type type) |
91 | 3 | : _is_init(false), _columns(columns), _schema_table_type(type) {} |
92 | | |
93 | 3 | SchemaScanner::~SchemaScanner() = default; |
94 | | |
95 | 0 | Status SchemaScanner::start(RuntimeState* state) { |
96 | 0 | if (!_is_init) { |
97 | 0 | return Status::InternalError("call Start before Init."); |
98 | 0 | } |
99 | | |
100 | 0 | return Status::OK(); |
101 | 0 | } |
102 | | |
103 | 0 | Status SchemaScanner::get_next_block(RuntimeState* state, vectorized::Block* block, bool* eos) { |
104 | 0 | if (_data_block == nullptr) { |
105 | 0 | return Status::InternalError("No data left!"); |
106 | 0 | } |
107 | 0 | DCHECK(_async_thread_running == false); |
108 | 0 | RETURN_IF_ERROR(_scanner_status.status()); |
109 | 0 | for (size_t i = 0; i < block->columns(); i++) { |
110 | 0 | std::move(*block->get_by_position(i).column) |
111 | 0 | .mutate() |
112 | 0 | ->insert_range_from(*_data_block->get_by_position(i).column, 0, |
113 | 0 | _data_block->rows()); |
114 | 0 | } |
115 | 0 | _data_block->clear_column_data(); |
116 | 0 | *eos = _eos; |
117 | 0 | if (!*eos) { |
118 | 0 | RETURN_IF_ERROR(get_next_block_async(state)); |
119 | 0 | } |
120 | 0 | return Status::OK(); |
121 | 0 | } |
122 | | |
123 | 0 | Status SchemaScanner::get_next_block_async(RuntimeState* state) { |
124 | 0 | _dependency->block(); |
125 | 0 | auto task_ctx = state->get_task_execution_context(); |
126 | 0 | RETURN_IF_ERROR(ExecEnv::GetInstance()->fragment_mgr()->get_thread_pool()->submit_func( |
127 | 0 | [this, task_ctx, state]() { |
128 | 0 | auto task_lock = task_ctx.lock(); |
129 | 0 | if (task_lock == nullptr) { |
130 | 0 | return; |
131 | 0 | } |
132 | 0 | DCHECK(_async_thread_running == false); |
133 | 0 | SCOPED_ATTACH_TASK(state); |
134 | 0 | _async_thread_running = true; |
135 | 0 | if (!_opened) { |
136 | 0 | _data_block = vectorized::Block::create_unique(); |
137 | 0 | _init_block(_data_block.get()); |
138 | 0 | _scanner_status.update(start(state)); |
139 | 0 | _opened = true; |
140 | 0 | } |
141 | 0 | bool eos = false; |
142 | 0 | auto call_next_block_internal = [&]() -> Status { |
143 | 0 | RETURN_IF_CATCH_EXCEPTION( |
144 | 0 | { return get_next_block_internal(_data_block.get(), &eos); }); |
145 | 0 | }; |
146 | 0 | _scanner_status.update(call_next_block_internal()); |
147 | 0 | _eos = eos; |
148 | 0 | _async_thread_running = false; |
149 | 0 | _dependency->set_ready(); |
150 | 0 | })); |
151 | 0 | return Status::OK(); |
152 | 0 | } |
153 | | |
154 | 0 | Status SchemaScanner::init(RuntimeState* state, SchemaScannerParam* param, ObjectPool* pool) { |
155 | 0 | if (_is_init) { |
156 | 0 | return Status::OK(); |
157 | 0 | } |
158 | 0 | if (nullptr == param || nullptr == pool) { |
159 | 0 | return Status::InternalError("invalid parameter"); |
160 | 0 | } |
161 | | |
162 | 0 | _param = param; |
163 | 0 | _timezone_obj = state->timezone_obj(); |
164 | 0 | _is_init = true; |
165 | |
|
166 | 0 | if (_param->profile) { |
167 | 0 | _get_db_timer = ADD_TIMER(_param->profile, "GetDbTime"); |
168 | 0 | _get_table_timer = ADD_TIMER(_param->profile, "GetTableTime"); |
169 | 0 | _get_describe_timer = ADD_TIMER(_param->profile, "GetDescribeTime"); |
170 | 0 | _fill_block_timer = ADD_TIMER(_param->profile, "FillBlockTime"); |
171 | 0 | } |
172 | |
|
173 | 0 | return Status::OK(); |
174 | 0 | } |
175 | | |
176 | 0 | std::unique_ptr<SchemaScanner> SchemaScanner::create(TSchemaTableType::type type) { |
177 | 0 | switch (type) { |
178 | 0 | case TSchemaTableType::SCH_TABLES: |
179 | 0 | return SchemaTablesScanner::create_unique(); |
180 | 0 | case TSchemaTableType::SCH_SCHEMATA: |
181 | 0 | return SchemaSchemataScanner::create_unique(); |
182 | 0 | case TSchemaTableType::SCH_COLUMNS: |
183 | 0 | return SchemaColumnsScanner::create_unique(); |
184 | 0 | case TSchemaTableType::SCH_CHARSETS: |
185 | 0 | return SchemaCharsetsScanner::create_unique(); |
186 | 0 | case TSchemaTableType::SCH_COLLATIONS: |
187 | 0 | return SchemaCollationsScanner::create_unique(); |
188 | 0 | case TSchemaTableType::SCH_GLOBAL_VARIABLES: |
189 | 0 | return SchemaVariablesScanner::create_unique(TVarType::GLOBAL); |
190 | 0 | case TSchemaTableType::SCH_SESSION_VARIABLES: |
191 | 0 | case TSchemaTableType::SCH_VARIABLES: |
192 | 0 | return SchemaVariablesScanner::create_unique(TVarType::SESSION); |
193 | 0 | case TSchemaTableType::SCH_VIEWS: |
194 | 0 | return SchemaViewsScanner::create_unique(); |
195 | 0 | case TSchemaTableType::SCH_TABLE_PRIVILEGES: |
196 | 0 | return SchemaTablePrivilegesScanner::create_unique(); |
197 | 0 | case TSchemaTableType::SCH_SCHEMA_PRIVILEGES: |
198 | 0 | return SchemaSchemaPrivilegesScanner::create_unique(); |
199 | 0 | case TSchemaTableType::SCH_USER_PRIVILEGES: |
200 | 0 | return SchemaUserPrivilegesScanner::create_unique(); |
201 | 0 | case TSchemaTableType::SCH_FILES: |
202 | 0 | return SchemaFilesScanner::create_unique(); |
203 | 0 | case TSchemaTableType::SCH_PARTITIONS: |
204 | 0 | return SchemaPartitionsScanner::create_unique(); |
205 | 0 | case TSchemaTableType::SCH_BACKEND_CONFIGURATION: |
206 | 0 | return SchemaBackendConfigurationScanner::create_unique(); |
207 | 0 | case TSchemaTableType::SCH_ROWSETS: |
208 | 0 | return SchemaRowsetsScanner::create_unique(); |
209 | 0 | case TSchemaTableType::SCH_METADATA_NAME_IDS: |
210 | 0 | return SchemaMetadataNameIdsScanner::create_unique(); |
211 | 0 | case TSchemaTableType::SCH_PROFILING: |
212 | 0 | return SchemaProfilingScanner::create_unique(); |
213 | 0 | case TSchemaTableType::SCH_BACKEND_ACTIVE_TASKS: |
214 | 0 | return SchemaBackendActiveTasksScanner::create_unique(); |
215 | 0 | case TSchemaTableType::SCH_ACTIVE_QUERIES: |
216 | 0 | return SchemaActiveQueriesScanner::create_unique(); |
217 | 0 | case TSchemaTableType::SCH_WORKLOAD_GROUPS: |
218 | 0 | return SchemaWorkloadGroupsScanner::create_unique(); |
219 | 0 | case TSchemaTableType::SCH_PROCESSLIST: |
220 | 0 | return SchemaProcessListScanner::create_unique(); |
221 | 0 | case TSchemaTableType::SCH_PROCEDURES: |
222 | 0 | return SchemaRoutinesScanner::create_unique(); |
223 | 0 | case TSchemaTableType::SCH_USER: |
224 | 0 | return SchemaUserScanner::create_unique(); |
225 | 0 | case TSchemaTableType::SCH_WORKLOAD_POLICY: |
226 | 0 | return SchemaWorkloadSchedulePolicyScanner::create_unique(); |
227 | 0 | case TSchemaTableType::SCH_TABLE_OPTIONS: |
228 | 0 | return SchemaTableOptionsScanner::create_unique(); |
229 | 0 | case TSchemaTableType::SCH_WORKLOAD_GROUP_PRIVILEGES: |
230 | 0 | return SchemaWorkloadGroupPrivilegesScanner::create_unique(); |
231 | 0 | case TSchemaTableType::SCH_WORKLOAD_GROUP_RESOURCE_USAGE: |
232 | 0 | return SchemaBackendWorkloadGroupResourceUsage::create_unique(); |
233 | 0 | case TSchemaTableType::SCH_TABLE_PROPERTIES: |
234 | 0 | return SchemaTablePropertiesScanner::create_unique(); |
235 | 0 | case TSchemaTableType::SCH_FILE_CACHE_STATISTICS: |
236 | 0 | return SchemaFileCacheStatisticsScanner::create_unique(); |
237 | 0 | case TSchemaTableType::SCH_CATALOG_META_CACHE_STATISTICS: |
238 | 0 | return SchemaCatalogMetaCacheStatsScanner::create_unique(); |
239 | 0 | case TSchemaTableType::SCH_BACKEND_KERBEROS_TICKET_CACHE: |
240 | 0 | return SchemaBackendKerberosTicketCacheScanner::create_unique(); |
241 | 0 | case TSchemaTableType::SCH_ROUTINE_LOAD_JOBS: |
242 | 0 | return SchemaRoutineLoadJobScanner::create_unique(); |
243 | 0 | case TSchemaTableType::SCH_BACKEND_TABLETS: |
244 | 0 | return SchemaTabletsScanner::create_unique(); |
245 | 0 | case TSchemaTableType::SCH_VIEW_DEPENDENCY: |
246 | 0 | return SchemaViewDependencyScanner::create_unique(); |
247 | 0 | case TSchemaTableType::SCH_SQL_BLOCK_RULE_STATUS: |
248 | 0 | return SchemaSqlBlockRuleStatusScanner::create_unique(); |
249 | 0 | case TSchemaTableType::SCH_ENCRYPTION_KEYS: |
250 | 0 | return SchemaEncryptionKeysScanner::create_unique(); |
251 | 0 | case TSchemaTableType::SCH_CLUSTER_SNAPSHOTS: |
252 | 0 | return SchemaClusterSnapshotsScanner::create_unique(); |
253 | 0 | case TSchemaTableType::SCH_CLUSTER_SNAPSHOT_PROPERTIES: |
254 | 0 | return SchemaClusterSnapshotPropertiesScanner::create_unique(); |
255 | 0 | case TSchemaTableType::SCH_COLUMN_DATA_SIZES: |
256 | 0 | return SchemaColumnDataSizesScanner::create_unique(); |
257 | 0 | default: |
258 | 0 | return SchemaDummyScanner::create_unique(); |
259 | 0 | break; |
260 | 0 | } |
261 | 0 | } |
262 | | |
263 | 3 | void SchemaScanner::_init_block(vectorized::Block* src_block) { |
264 | 3 | const std::vector<SchemaScanner::ColumnDesc>& columns_desc(get_column_desc()); |
265 | 30 | for (int i = 0; i < columns_desc.size(); ++i) { |
266 | 27 | auto data_type = vectorized::DataTypeFactory::instance().create_data_type( |
267 | 27 | columns_desc[i].type, true); |
268 | 27 | src_block->insert(vectorized::ColumnWithTypeAndName(data_type->create_column(), data_type, |
269 | 27 | columns_desc[i].name)); |
270 | 27 | } |
271 | 3 | } |
272 | | |
273 | | Status SchemaScanner::fill_dest_column_for_range(vectorized::Block* block, size_t pos, |
274 | 23 | const std::vector<void*>& datas) { |
275 | 23 | const ColumnDesc& col_desc = _columns[pos]; |
276 | 23 | vectorized::MutableColumnPtr column_ptr; |
277 | 23 | column_ptr = std::move(*block->get_by_position(pos).column).assume_mutable(); |
278 | 23 | vectorized::IColumn* col_ptr = column_ptr.get(); |
279 | | |
280 | 23 | auto* nullable_column = reinterpret_cast<vectorized::ColumnNullable*>(col_ptr); |
281 | | |
282 | | // Resize in advance to improve insertion efficiency. |
283 | 23 | size_t fill_num = datas.size(); |
284 | 23 | col_ptr = &nullable_column->get_nested_column(); |
285 | 58 | for (int i = 0; i < fill_num; ++i) { |
286 | 35 | auto* data = datas[i]; |
287 | 35 | if (data == nullptr) { |
288 | | // For nested column need not insert default. |
289 | 11 | nullable_column->insert_data(nullptr, 0); |
290 | 11 | continue; |
291 | 24 | } else { |
292 | 24 | nullable_column->push_false_to_nullmap(1); |
293 | 24 | } |
294 | 24 | switch (col_desc.type) { |
295 | 0 | case TYPE_HLL: { |
296 | 0 | auto* hll_slot = reinterpret_cast<HyperLogLog*>(data); |
297 | 0 | assert_cast<vectorized::ColumnHLL*>(col_ptr)->get_data().emplace_back(*hll_slot); |
298 | 0 | break; |
299 | 0 | } |
300 | 0 | case TYPE_VARCHAR: |
301 | 0 | case TYPE_CHAR: |
302 | 12 | case TYPE_STRING: { |
303 | 12 | auto* str_slot = reinterpret_cast<StringRef*>(data); |
304 | 12 | assert_cast<vectorized::ColumnString*>(col_ptr)->insert_data(str_slot->data, |
305 | 12 | str_slot->size); |
306 | 12 | break; |
307 | 0 | } |
308 | | |
309 | 1 | case TYPE_BOOLEAN: { |
310 | 1 | uint8_t num = *reinterpret_cast<bool*>(data); |
311 | 1 | assert_cast<vectorized::ColumnBool*>(col_ptr)->insert_value(num); |
312 | 1 | break; |
313 | 0 | } |
314 | | |
315 | 0 | case TYPE_TINYINT: { |
316 | 0 | int8_t num = *reinterpret_cast<int8_t*>(data); |
317 | 0 | assert_cast<vectorized::ColumnInt8*>(col_ptr)->insert_value(num); |
318 | 0 | break; |
319 | 0 | } |
320 | | |
321 | 0 | case TYPE_SMALLINT: { |
322 | 0 | int16_t num = *reinterpret_cast<int16_t*>(data); |
323 | 0 | assert_cast<vectorized::ColumnInt16*>(col_ptr)->insert_value(num); |
324 | 0 | break; |
325 | 0 | } |
326 | | |
327 | 4 | case TYPE_INT: { |
328 | 4 | int32_t num = *reinterpret_cast<int32_t*>(data); |
329 | 4 | assert_cast<vectorized::ColumnInt32*>(col_ptr)->insert_value(num); |
330 | 4 | break; |
331 | 0 | } |
332 | | |
333 | 3 | case TYPE_BIGINT: { |
334 | 3 | int64_t num = *reinterpret_cast<int64_t*>(data); |
335 | 3 | assert_cast<vectorized::ColumnInt64*>(col_ptr)->insert_value(num); |
336 | 3 | break; |
337 | 0 | } |
338 | | |
339 | 0 | case TYPE_LARGEINT: { |
340 | 0 | __int128 num; |
341 | 0 | memcpy(&num, data, sizeof(__int128)); |
342 | 0 | assert_cast<vectorized::ColumnInt128*>(col_ptr)->insert_value(num); |
343 | 0 | break; |
344 | 0 | } |
345 | | |
346 | 0 | case TYPE_FLOAT: { |
347 | 0 | float num = *reinterpret_cast<float*>(data); |
348 | 0 | assert_cast<vectorized::ColumnFloat32*>(col_ptr)->insert_value(num); |
349 | 0 | break; |
350 | 0 | } |
351 | | |
352 | 0 | case TYPE_DOUBLE: { |
353 | 0 | double num = *reinterpret_cast<double*>(data); |
354 | 0 | assert_cast<vectorized::ColumnFloat64*>(col_ptr)->insert_value(num); |
355 | 0 | break; |
356 | 0 | } |
357 | | |
358 | 0 | case TYPE_DATE: { |
359 | 0 | assert_cast<vectorized::ColumnDate*>(col_ptr)->insert_data( |
360 | 0 | reinterpret_cast<char*>(data), 0); |
361 | 0 | break; |
362 | 0 | } |
363 | | |
364 | 0 | case TYPE_DATEV2: { |
365 | 0 | uint32_t num = *reinterpret_cast<uint32_t*>(data); |
366 | 0 | assert_cast<vectorized::ColumnDateV2*>(col_ptr)->insert_value(num); |
367 | 0 | break; |
368 | 0 | } |
369 | | |
370 | 0 | case TYPE_DATETIME: { |
371 | 0 | assert_cast<vectorized::ColumnDateTime*>(col_ptr)->insert_data( |
372 | 0 | reinterpret_cast<char*>(data), 0); |
373 | 0 | break; |
374 | 0 | } |
375 | | |
376 | 4 | case TYPE_DATETIMEV2: { |
377 | 4 | uint64_t num = *reinterpret_cast<uint64_t*>(data); |
378 | 4 | assert_cast<vectorized::ColumnDateTimeV2*>(col_ptr)->insert_value(num); |
379 | 4 | break; |
380 | 0 | } |
381 | | |
382 | 0 | case TYPE_DECIMALV2: { |
383 | 0 | const vectorized::Int128 num = (reinterpret_cast<PackedInt128*>(data))->value; |
384 | 0 | assert_cast<vectorized::ColumnDecimal128V2*>(col_ptr)->insert_data( |
385 | 0 | reinterpret_cast<const char*>(&num), 0); |
386 | 0 | break; |
387 | 0 | } |
388 | 0 | case TYPE_DECIMAL128I: { |
389 | 0 | const vectorized::Int128 num = (reinterpret_cast<PackedInt128*>(data))->value; |
390 | 0 | assert_cast<vectorized::ColumnDecimal128V3*>(col_ptr)->insert_data( |
391 | 0 | reinterpret_cast<const char*>(&num), 0); |
392 | 0 | break; |
393 | 0 | } |
394 | | |
395 | 0 | case TYPE_DECIMAL32: { |
396 | 0 | const int32_t num = *reinterpret_cast<int32_t*>(data); |
397 | 0 | assert_cast<vectorized::ColumnDecimal32*>(col_ptr)->insert_data( |
398 | 0 | reinterpret_cast<const char*>(&num), 0); |
399 | 0 | break; |
400 | 0 | } |
401 | | |
402 | 0 | case TYPE_DECIMAL64: { |
403 | 0 | const int64_t num = *reinterpret_cast<int64_t*>(data); |
404 | 0 | assert_cast<vectorized::ColumnDecimal64*>(col_ptr)->insert_data( |
405 | 0 | reinterpret_cast<const char*>(&num), 0); |
406 | 0 | break; |
407 | 0 | } |
408 | | |
409 | 0 | default: { |
410 | 0 | DCHECK(false) << "bad slot type: " << col_desc.type; |
411 | 0 | std::stringstream ss; |
412 | 0 | ss << "Fail to convert schema type:'" << col_desc.type << " on column:`" |
413 | 0 | << std::string(col_desc.name) + "`"; |
414 | 0 | return Status::InternalError(ss.str()); |
415 | 0 | } |
416 | 24 | } |
417 | 24 | } |
418 | 23 | return Status::OK(); |
419 | 23 | } |
420 | | |
421 | 0 | std::string SchemaScanner::get_db_from_full_name(const std::string& full_name) { |
422 | 0 | std::vector<std::string> part = split(full_name, "."); |
423 | 0 | if (part.size() == 2) { |
424 | 0 | return part[1]; |
425 | 0 | } |
426 | 0 | return full_name; |
427 | 0 | } |
428 | | |
429 | | Status SchemaScanner::insert_block_column(TCell cell, int col_index, vectorized::Block* block, |
430 | 0 | PrimitiveType type) { |
431 | 0 | vectorized::MutableColumnPtr mutable_col_ptr; |
432 | 0 | mutable_col_ptr = std::move(*block->get_by_position(col_index).column).assume_mutable(); |
433 | 0 | auto* nullable_column = reinterpret_cast<vectorized::ColumnNullable*>(mutable_col_ptr.get()); |
434 | 0 | vectorized::IColumn* col_ptr = &nullable_column->get_nested_column(); |
435 | |
|
436 | 0 | switch (type) { |
437 | 0 | case TYPE_BIGINT: { |
438 | 0 | reinterpret_cast<vectorized::ColumnInt64*>(col_ptr)->insert_value(cell.longVal); |
439 | 0 | break; |
440 | 0 | } |
441 | | |
442 | 0 | case TYPE_INT: { |
443 | 0 | reinterpret_cast<vectorized::ColumnInt32*>(col_ptr)->insert_value(cell.intVal); |
444 | 0 | break; |
445 | 0 | } |
446 | | |
447 | 0 | case TYPE_BOOLEAN: { |
448 | 0 | reinterpret_cast<vectorized::ColumnUInt8*>(col_ptr)->insert_value(cell.boolVal); |
449 | 0 | break; |
450 | 0 | } |
451 | | |
452 | 0 | case TYPE_STRING: |
453 | 0 | case TYPE_VARCHAR: |
454 | 0 | case TYPE_CHAR: { |
455 | 0 | reinterpret_cast<vectorized::ColumnString*>(col_ptr)->insert_data(cell.stringVal.data(), |
456 | 0 | cell.stringVal.size()); |
457 | 0 | break; |
458 | 0 | } |
459 | | |
460 | 0 | case TYPE_DATETIME: { |
461 | 0 | std::vector<void*> datas(1); |
462 | 0 | VecDateTimeValue src[1]; |
463 | 0 | src[0].from_date_str(cell.stringVal.data(), cell.stringVal.size()); |
464 | 0 | datas[0] = src; |
465 | 0 | auto data = datas[0]; |
466 | 0 | reinterpret_cast<vectorized::ColumnDateTime*>(col_ptr)->insert_data( |
467 | 0 | reinterpret_cast<char*>(data), 0); |
468 | 0 | break; |
469 | 0 | } |
470 | 0 | default: { |
471 | 0 | std::stringstream ss; |
472 | 0 | ss << "unsupported column type:" << type; |
473 | 0 | return Status::InternalError(ss.str()); |
474 | 0 | } |
475 | 0 | } |
476 | 0 | nullable_column->push_false_to_nullmap(1); |
477 | 0 | return Status::OK(); |
478 | 0 | } |
479 | | |
480 | | } // namespace doris |