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