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