2012-01-10 22:11:51 +00:00
|
|
|
|
#pragma once
|
|
|
|
|
|
2015-09-29 19:19:54 +00:00
|
|
|
|
#include <common/logger_useful.h>
|
2012-01-10 22:11:51 +00:00
|
|
|
|
|
2013-05-03 02:25:50 +00:00
|
|
|
|
#include <DB/Common/ConcurrentBoundedQueue.h>
|
2012-01-10 22:11:51 +00:00
|
|
|
|
#include <DB/DataStreams/IProfilingBlockInputStream.h>
|
2014-11-30 18:22:57 +00:00
|
|
|
|
#include <DB/DataStreams/ParallelInputsProcessor.h>
|
2012-01-10 22:11:51 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace DB
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
using Poco::SharedPtr;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** Объединяет несколько источников в один.
|
|
|
|
|
* Блоки из разных источников перемежаются друг с другом произвольным образом.
|
|
|
|
|
* Можно указать количество потоков (max_threads),
|
|
|
|
|
* в которых будет выполняться получение данных из разных источников.
|
2012-09-24 02:05:40 +00:00
|
|
|
|
*
|
|
|
|
|
* Устроено так:
|
2014-11-30 18:22:57 +00:00
|
|
|
|
* - с помощью ParallelInputsProcessor в нескольких потоках вынимает из источников блоки;
|
2012-09-24 02:05:40 +00:00
|
|
|
|
* - полученные блоки складываются в ограниченную очередь готовых блоков;
|
|
|
|
|
* - основной поток вынимает готовые блоки из очереди готовых блоков.
|
2012-01-10 22:11:51 +00:00
|
|
|
|
*/
|
2014-11-30 18:22:57 +00:00
|
|
|
|
|
|
|
|
|
|
2012-01-10 22:11:51 +00:00
|
|
|
|
class UnionBlockInputStream : public IProfilingBlockInputStream
|
|
|
|
|
{
|
|
|
|
|
public:
|
2015-07-21 21:29:02 +00:00
|
|
|
|
UnionBlockInputStream(BlockInputStreams inputs, BlockInputStreamPtr additional_input_at_end, size_t max_threads) :
|
2015-04-22 21:26:12 +00:00
|
|
|
|
output_queue(std::min(inputs.size(), max_threads)),
|
|
|
|
|
handler(*this),
|
2015-07-21 21:29:02 +00:00
|
|
|
|
processor(inputs, additional_input_at_end, max_threads, handler)
|
2012-01-10 22:11:51 +00:00
|
|
|
|
{
|
2014-11-30 18:22:57 +00:00
|
|
|
|
children = inputs;
|
2015-07-21 21:29:02 +00:00
|
|
|
|
if (additional_input_at_end)
|
|
|
|
|
children.push_back(additional_input_at_end);
|
2012-01-10 22:11:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
2015-06-08 20:22:02 +00:00
|
|
|
|
String getName() const override { return "Union"; }
|
2012-10-20 02:10:47 +00:00
|
|
|
|
|
2014-11-08 23:52:18 +00:00
|
|
|
|
String getID() const override
|
2013-05-03 10:20:53 +00:00
|
|
|
|
{
|
|
|
|
|
std::stringstream res;
|
|
|
|
|
res << "Union(";
|
|
|
|
|
|
|
|
|
|
Strings children_ids(children.size());
|
|
|
|
|
for (size_t i = 0; i < children.size(); ++i)
|
|
|
|
|
children_ids[i] = children[i]->getID();
|
|
|
|
|
|
|
|
|
|
/// Порядок не имеет значения.
|
|
|
|
|
std::sort(children_ids.begin(), children_ids.end());
|
|
|
|
|
|
|
|
|
|
for (size_t i = 0; i < children_ids.size(); ++i)
|
|
|
|
|
res << (i == 0 ? "" : ", ") << children_ids[i];
|
|
|
|
|
|
|
|
|
|
res << ")";
|
|
|
|
|
return res.str();
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-13 20:33:09 +00:00
|
|
|
|
|
2014-11-08 23:52:18 +00:00
|
|
|
|
~UnionBlockInputStream() override
|
2012-10-20 02:10:47 +00:00
|
|
|
|
{
|
2013-09-14 05:14:22 +00:00
|
|
|
|
try
|
|
|
|
|
{
|
2013-11-25 10:46:25 +00:00
|
|
|
|
if (!all_read)
|
|
|
|
|
cancel();
|
2013-11-29 18:44:02 +00:00
|
|
|
|
|
|
|
|
|
finalize();
|
2013-09-14 05:14:22 +00:00
|
|
|
|
}
|
|
|
|
|
catch (...)
|
|
|
|
|
{
|
2014-12-14 08:27:22 +00:00
|
|
|
|
tryLogCurrentException(__PRETTY_FUNCTION__);
|
2013-09-14 05:14:22 +00:00
|
|
|
|
}
|
2012-10-20 02:10:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-10-30 19:17:41 +00:00
|
|
|
|
/** Отличается от реализации по-умолчанию тем, что пытается остановить все источники,
|
|
|
|
|
* пропуская отвалившиеся по эксепшену.
|
|
|
|
|
*/
|
2014-11-08 23:52:18 +00:00
|
|
|
|
void cancel() override
|
2012-10-30 19:17:41 +00:00
|
|
|
|
{
|
2015-03-20 16:20:47 +00:00
|
|
|
|
bool old_val = false;
|
|
|
|
|
if (!is_cancelled.compare_exchange_strong(old_val, true, std::memory_order_seq_cst, std::memory_order_relaxed))
|
2012-11-10 05:13:46 +00:00
|
|
|
|
return;
|
2012-11-10 04:42:26 +00:00
|
|
|
|
|
2014-12-14 08:27:22 +00:00
|
|
|
|
//std::cerr << "cancelling\n";
|
2014-11-30 18:22:57 +00:00
|
|
|
|
processor.cancel();
|
2013-11-29 18:44:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-11-25 10:46:25 +00:00
|
|
|
|
|
2013-11-29 18:44:02 +00:00
|
|
|
|
protected:
|
|
|
|
|
void finalize()
|
|
|
|
|
{
|
2014-11-30 18:22:57 +00:00
|
|
|
|
if (!started)
|
2013-12-27 13:22:32 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2013-11-25 10:46:25 +00:00
|
|
|
|
LOG_TRACE(log, "Waiting for threads to finish");
|
|
|
|
|
|
2014-12-14 08:27:22 +00:00
|
|
|
|
ExceptionPtr exception;
|
|
|
|
|
if (!all_read)
|
|
|
|
|
{
|
|
|
|
|
/** Прочитаем всё до конца, чтобы ParallelInputsProcessor не заблокировался при попытке вставить в очередь.
|
|
|
|
|
* Может быть, в очереди есть ещё эксепшен.
|
|
|
|
|
*/
|
|
|
|
|
OutputData res;
|
|
|
|
|
while (true)
|
|
|
|
|
{
|
|
|
|
|
//std::cerr << "popping\n";
|
|
|
|
|
output_queue.pop(res);
|
|
|
|
|
|
|
|
|
|
if (res.exception)
|
|
|
|
|
{
|
|
|
|
|
if (!exception)
|
|
|
|
|
exception = res.exception;
|
|
|
|
|
else if (DB::Exception * e = dynamic_cast<DB::Exception *>(&*exception))
|
|
|
|
|
e->addMessage("\n" + res.exception->displayText());
|
|
|
|
|
}
|
|
|
|
|
else if (!res.block)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
all_read = true;
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
processor.wait();
|
2013-11-29 18:44:02 +00:00
|
|
|
|
|
2013-11-25 10:46:25 +00:00
|
|
|
|
LOG_TRACE(log, "Waited for threads to finish");
|
2014-12-14 08:27:22 +00:00
|
|
|
|
|
|
|
|
|
if (exception)
|
|
|
|
|
exception->rethrow();
|
2012-10-30 19:17:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-12-14 08:27:22 +00:00
|
|
|
|
/** Возможны следующие варианты:
|
|
|
|
|
* 1. Функция readImpl вызывается до тех пор, пока она не вернёт пустой блок.
|
|
|
|
|
* Затем вызывается функция readSuffix и затем деструктор.
|
|
|
|
|
* 2. Вызывается функция readImpl. В какой-то момент, возможно из другого потока вызывается функция cancel.
|
|
|
|
|
* Затем вызывается функция readSuffix и затем деструктор.
|
|
|
|
|
* 3. В любой момент, объект может быть и так уничтожен (вызываться деструктор).
|
|
|
|
|
*/
|
|
|
|
|
|
2014-11-08 23:52:18 +00:00
|
|
|
|
Block readImpl() override
|
2012-01-10 22:11:51 +00:00
|
|
|
|
{
|
2012-10-12 16:53:45 +00:00
|
|
|
|
OutputData res;
|
2013-11-29 08:08:43 +00:00
|
|
|
|
if (all_read)
|
2012-10-12 16:53:45 +00:00
|
|
|
|
return res.block;
|
2012-10-20 02:10:47 +00:00
|
|
|
|
|
2012-09-24 02:05:40 +00:00
|
|
|
|
/// Запускаем потоки, если это ещё не было сделано.
|
2014-11-30 18:22:57 +00:00
|
|
|
|
if (!started)
|
2012-01-10 22:11:51 +00:00
|
|
|
|
{
|
2014-11-30 18:22:57 +00:00
|
|
|
|
started = true;
|
|
|
|
|
processor.process();
|
2012-09-24 02:05:40 +00:00
|
|
|
|
}
|
2012-06-24 23:17:06 +00:00
|
|
|
|
|
2012-10-12 16:53:45 +00:00
|
|
|
|
/// Будем ждать, пока будет готов следующий блок или будет выкинуто исключение.
|
2014-12-14 08:27:22 +00:00
|
|
|
|
//std::cerr << "popping\n";
|
2012-09-24 02:05:40 +00:00
|
|
|
|
output_queue.pop(res);
|
2012-01-10 22:11:51 +00:00
|
|
|
|
|
2012-10-12 16:53:45 +00:00
|
|
|
|
if (res.exception)
|
|
|
|
|
res.exception->rethrow();
|
|
|
|
|
|
2012-11-10 04:42:26 +00:00
|
|
|
|
if (!res.block)
|
|
|
|
|
all_read = true;
|
|
|
|
|
|
2012-10-12 16:53:45 +00:00
|
|
|
|
return res.block;
|
2012-01-10 22:11:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-12-14 08:27:22 +00:00
|
|
|
|
/// Вызывается либо после того, как всё прочитано, либо после cancel-а.
|
2014-11-08 23:52:18 +00:00
|
|
|
|
void readSuffix() override
|
2013-09-13 20:33:09 +00:00
|
|
|
|
{
|
2014-12-14 08:27:22 +00:00
|
|
|
|
//std::cerr << "readSuffix\n";
|
2015-03-20 16:20:47 +00:00
|
|
|
|
if (!all_read && !is_cancelled.load(std::memory_order_seq_cst))
|
2013-12-27 13:22:32 +00:00
|
|
|
|
throw Exception("readSuffix called before all data is read", ErrorCodes::LOGICAL_ERROR);
|
2013-11-29 15:04:07 +00:00
|
|
|
|
|
2013-12-27 13:22:32 +00:00
|
|
|
|
finalize();
|
|
|
|
|
|
|
|
|
|
for (size_t i = 0; i < children.size(); ++i)
|
|
|
|
|
children[i]->readSuffix();
|
2013-09-13 20:33:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-09-24 02:05:40 +00:00
|
|
|
|
private:
|
2014-11-30 18:22:57 +00:00
|
|
|
|
/// Блок или эксепшен.
|
|
|
|
|
struct OutputData
|
2012-01-10 22:11:51 +00:00
|
|
|
|
{
|
2014-11-30 18:22:57 +00:00
|
|
|
|
Block block;
|
|
|
|
|
ExceptionPtr exception;
|
2012-01-10 22:11:51 +00:00
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
OutputData() {}
|
|
|
|
|
OutputData(Block & block_) : block(block_) {}
|
|
|
|
|
OutputData(ExceptionPtr & exception_) : exception(exception_) {}
|
2012-01-10 22:11:51 +00:00
|
|
|
|
};
|
|
|
|
|
|
2014-12-14 08:27:22 +00:00
|
|
|
|
/** Очередь готовых блоков. Также туда можно положить эксепшен вместо блока.
|
|
|
|
|
* Когда данные закончатся - в очередь вставляется пустой блок.
|
|
|
|
|
* В очередь всегда (даже после исключения или отмены запроса) рано или поздно вставляется пустой блок.
|
|
|
|
|
* Очередь всегда (даже после исключения или отмены запроса, даже в деструкторе) нужно дочитывать до пустого блока,
|
|
|
|
|
* иначе ParallelInputsProcessor может заблокироваться при вставке в очередь.
|
|
|
|
|
*/
|
2014-11-30 18:22:57 +00:00
|
|
|
|
typedef ConcurrentBoundedQueue<OutputData> OutputQueue;
|
|
|
|
|
OutputQueue output_queue;
|
2012-09-24 02:05:40 +00:00
|
|
|
|
|
2014-07-16 02:06:58 +00:00
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
struct Handler
|
|
|
|
|
{
|
|
|
|
|
Handler(UnionBlockInputStream & parent_) : parent(parent_) {}
|
2012-09-04 19:57:17 +00:00
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
void onBlock(Block & block, size_t thread_num)
|
2012-01-10 22:11:51 +00:00
|
|
|
|
{
|
2014-12-14 08:27:22 +00:00
|
|
|
|
//std::cerr << "pushing block\n";
|
2014-11-30 18:22:57 +00:00
|
|
|
|
parent.output_queue.push(block);
|
2012-09-24 02:05:40 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
void onFinish()
|
2012-09-24 02:05:40 +00:00
|
|
|
|
{
|
2014-12-14 08:27:22 +00:00
|
|
|
|
//std::cerr << "pushing end\n";
|
2014-11-30 18:22:57 +00:00
|
|
|
|
parent.output_queue.push(OutputData());
|
2012-01-10 22:11:51 +00:00
|
|
|
|
}
|
2012-09-03 19:52:57 +00:00
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
void onException(ExceptionPtr & exception, size_t thread_num)
|
2014-07-16 02:06:58 +00:00
|
|
|
|
{
|
2014-12-14 08:27:22 +00:00
|
|
|
|
//std::cerr << "pushing exception\n";
|
2012-09-24 02:05:40 +00:00
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
/// Порядок строк имеет значение. Если его поменять, то возможна ситуация,
|
|
|
|
|
/// когда перед эксепшеном, в очередь окажется вставлен пустой блок (конец данных),
|
2014-12-14 08:27:22 +00:00
|
|
|
|
/// и эксепшен потеряется.
|
2012-09-24 02:05:40 +00:00
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
parent.output_queue.push(exception);
|
2014-12-14 08:27:22 +00:00
|
|
|
|
parent.cancel(); /// Не кидает исключений.
|
2014-11-30 18:22:57 +00:00
|
|
|
|
}
|
2012-10-12 16:53:45 +00:00
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
UnionBlockInputStream & parent;
|
2012-10-12 16:53:45 +00:00
|
|
|
|
};
|
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
Handler handler;
|
|
|
|
|
ParallelInputsProcessor<Handler> processor;
|
2014-07-16 01:36:18 +00:00
|
|
|
|
|
2014-11-30 18:22:57 +00:00
|
|
|
|
bool started = false;
|
|
|
|
|
bool all_read = false;
|
2012-09-24 02:05:40 +00:00
|
|
|
|
|
2014-07-16 01:36:18 +00:00
|
|
|
|
Logger * log = &Logger::get("UnionBlockInputStream");
|
2012-01-10 22:11:51 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
}
|