static ASTPtr generateCCs(std::vector<ConsistentContent>* ccs, const char* format, const char*** wordSourcesPtr, const LengthFunc** lengthFuncsPtr, va_list args) { ccs->clear(); std::string evaluatedFormat; vsprintf(&evaluatedFormat, format, args); const char* f_begin = evaluatedFormat.c_str(); const char* f_at = f_begin; ASTPtr root; try { //printf("\n\n%s\n", format); root = parseFormat(&f_at, wordSourcesPtr, lengthFuncsPtr); root->convertLLSharesToLength(); root->computeStartEndCols(0, root->getFixedLength()); std::vector<FillerPtr> topFillersStack, bottomFillersStack; root->flatten(root, root, ccs, true, &topFillersStack, &bottomFillersStack); //root->print(); //printf("\n"); for (ConsistentContent& cc : *ccs) { cc.generateCCLines(); } root->computeNumContentLines(); root->computeNumTotalLines(true); root->computeBlockVerticalFillersShares(); //printf("\n"); for (ConsistentContent& cc : *ccs) { /*printf("\n"); cc.print(); printf("\n"); printf("content: %d fixed: %d total: %d\n", cc.srcAst->numContentLines, cc.srcAst->numFixedLines, cc.srcAst->numTotalLines);*/ cc.generateLinesChars(root->numTotalLines); } //printf("\n\n"); } catch (DSLException& e) { fprintf(stderr, "%s\n", f_begin); for (int i = 0; i < e.f_at - f_begin; ++i) { fputc(' ', stderr); } fprintf(stderr, "^\n"); fprintf(stderr, "Error at %d: %s\n", e.f_at - f_begin, e.what()); return ASTPtr(); } return root; }
PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream( const String & database, const String & table, const StoragePtr & storage_, const Context & context_, const ASTPtr & query_ptr_, bool no_destination) : storage(storage_), context(context_), query_ptr(query_ptr_) { /** TODO This is a very important line. At any insertion into the table one of streams should own lock. * Although now any insertion into the table is done via PushingToViewsBlockOutputStream, * but it's clear that here is not the best place for this functionality. */ addTableLock(storage->lockStructure(true)); /// If the "root" table deduplactes blocks, there are no need to make deduplication for children /// Moreover, deduplication for AggregatingMergeTree children could produce false positives due to low size of inserting blocks bool disable_deduplication_for_children = !no_destination && storage->supportsDeduplication(); if (!table.empty()) { Dependencies dependencies = context.getDependencies(database, table); /// We need special context for materialized views insertions if (!dependencies.empty()) { views_context = std::make_unique<Context>(context); // Do not deduplicate insertions into MV if the main insertion is Ok if (disable_deduplication_for_children) views_context->getSettingsRef().insert_deduplicate = false; } for (const auto & database_table : dependencies) { auto dependent_table = context.getTable(database_table.first, database_table.second); auto & materialized_view = dynamic_cast<const StorageMaterializedView &>(*dependent_table); if (StoragePtr inner_table = materialized_view.tryGetTargetTable()) addTableLock(inner_table->lockStructure(true)); auto query = materialized_view.getInnerQuery(); BlockOutputStreamPtr out = std::make_shared<PushingToViewsBlockOutputStream>( database_table.first, database_table.second, dependent_table, *views_context, ASTPtr()); views.emplace_back(ViewInfo{std::move(query), database_table.first, database_table.second, std::move(out)}); } } /* Do not push to destination table if the flag is set */ if (!no_destination) { output = storage->write(query_ptr, context.getSettingsRef()); replicated_output = dynamic_cast<ReplicatedMergeTreeBlockOutputStream *>(output.get()); } }
PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream( String database, String table, StoragePtr storage, const Context & context_, const ASTPtr & query_ptr_, bool no_destination) : context(context_), query_ptr(query_ptr_) { /** TODO This is a very important line. At any insertion into the table one of streams should own lock. * Although now any insertion into the table is done via PushingToViewsBlockOutputStream, * but it's clear that here is not the best place for this functionality. */ addTableLock(storage->lockStructure(true, __PRETTY_FUNCTION__)); if (!table.empty()) { Dependencies dependencies = context.getDependencies(database, table); /// We need special context for materialized views insertions if (!dependencies.empty()) { views_context = std::make_unique<Context>(context); // Do not deduplicate insertions into MV if the main insertion is Ok views_context->getSettingsRef().insert_deduplicate = false; } for (const auto & database_table : dependencies) { auto dependent_table = context.getTable(database_table.first, database_table.second); auto & materialized_view = dynamic_cast<const StorageMaterializedView &>(*dependent_table); auto query = materialized_view.getInnerQuery(); auto out = std::make_shared<PushingToViewsBlockOutputStream>( database_table.first, database_table.second, dependent_table, *views_context, ASTPtr()); views.emplace_back(ViewInfo{std::move(query), database_table.first, database_table.second, std::move(out)}); } } /* Do not push to destination table if the flag is set */ if (!no_destination) { output = storage->write(query_ptr, context.getSettingsRef()); replicated_output = dynamic_cast<ReplicatedMergeTreeBlockOutputStream *>(output.get()); } }