ClickHouse/programs/odbc-bridge/ODBCBlockInputStream.cpp

151 lines
5.4 KiB
C++
Raw Normal View History

#include "ODBCBlockInputStream.h"
#include <vector>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <Common/assert_cast.h>
2018-09-05 16:20:12 +00:00
#include <IO/ReadHelpers.h>
2018-06-05 19:46:49 +00:00
#include <IO/WriteHelpers.h>
#include <common/logger_useful.h>
2017-06-06 17:18:32 +00:00
#include <ext/range.h>
2016-12-08 02:49:04 +00:00
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_COLUMNS_DOESNT_MATCH;
extern const int UNKNOWN_TYPE;
2016-12-08 02:49:04 +00:00
}
ODBCBlockInputStream::ODBCBlockInputStream(
2019-08-03 11:02:40 +00:00
Poco::Data::Session && session_, const std::string & query_str, const Block & sample_block, const UInt64 max_block_size_)
: session{session_}
, statement{(this->session << query_str, Poco::Data::Keywords::now)}
, result{statement}
, iterator{result.begin()}
2019-08-03 11:02:40 +00:00
, max_block_size{max_block_size_}
2020-05-30 21:57:37 +00:00
, log(&Poco::Logger::get("ODBCBlockInputStream"))
2016-12-08 02:49:04 +00:00
{
if (sample_block.columns() != result.columnCount())
throw Exception{"RecordSet contains " + toString(result.columnCount()) + " columns while " + toString(sample_block.columns())
+ " expected",
ErrorCodes::NUMBER_OF_COLUMNS_DOESNT_MATCH};
2016-12-08 02:49:04 +00:00
description.init(sample_block);
2016-12-08 02:49:04 +00:00
}
namespace
{
using ValueType = ExternalResultDescription::ValueType;
2020-03-09 03:38:43 +00:00
void insertValue(IColumn & column, const ValueType type, const Poco::Dynamic::Var & value)
{
switch (type)
{
2019-08-03 11:02:40 +00:00
case ValueType::vtUInt8:
assert_cast<ColumnUInt8 &>(column).insertValue(value.convert<UInt64>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtUInt16:
assert_cast<ColumnUInt16 &>(column).insertValue(value.convert<UInt64>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtUInt32:
assert_cast<ColumnUInt32 &>(column).insertValue(value.convert<UInt64>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtUInt64:
assert_cast<ColumnUInt64 &>(column).insertValue(value.convert<UInt64>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtInt8:
assert_cast<ColumnInt8 &>(column).insertValue(value.convert<Int64>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtInt16:
assert_cast<ColumnInt16 &>(column).insertValue(value.convert<Int64>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtInt32:
assert_cast<ColumnInt32 &>(column).insertValue(value.convert<Int64>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtInt64:
assert_cast<ColumnInt64 &>(column).insertValue(value.convert<Int64>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtFloat32:
assert_cast<ColumnFloat32 &>(column).insertValue(value.convert<Float64>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtFloat64:
assert_cast<ColumnFloat64 &>(column).insertValue(value.convert<Float64>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtString:
assert_cast<ColumnString &>(column).insert(value.convert<String>());
break;
2019-08-03 11:02:40 +00:00
case ValueType::vtDate:
2020-11-26 04:11:34 +00:00
{
2020-11-23 10:32:56 +00:00
Poco::DateTime date = value.convert<Poco::DateTime>();
assert_cast<ColumnUInt16 &>(column).insertValue(UInt16{LocalDate(date.year(), date.month(), date.day()).getDayNum()});
break;
2020-11-26 04:11:34 +00:00
}
2019-08-03 11:02:40 +00:00
case ValueType::vtDateTime:
2020-11-26 04:11:34 +00:00
{
2020-11-23 10:32:56 +00:00
Poco::DateTime datetime = value.convert<Poco::DateTime>();
assert_cast<ColumnUInt32 &>(column).insertValue(time_t{LocalDateTime(
datetime.year(), datetime.month(), datetime.day(), datetime.hour(), datetime.minute(), datetime.second())});
break;
2020-11-26 04:11:34 +00:00
}
2019-08-03 11:02:40 +00:00
case ValueType::vtUUID:
assert_cast<ColumnUInt128 &>(column).insert(parse<UUID>(value.convert<std::string>()));
break;
default:
throw Exception("Unsupported value type", ErrorCodes::UNKNOWN_TYPE);
}
}
void insertDefaultValue(IColumn & column, const IColumn & sample_column) { column.insertFrom(sample_column, 0); }
2016-12-08 02:49:04 +00:00
}
Block ODBCBlockInputStream::readImpl()
{
if (iterator == result.end())
return {};
2016-12-08 02:49:04 +00:00
MutableColumns columns(description.sample_block.columns());
for (const auto i : ext::range(0, columns.size()))
columns[i] = description.sample_block.getByPosition(i).column->cloneEmpty();
size_t num_rows = 0;
while (iterator != result.end())
{
Poco::Data::Row & row = *iterator;
2016-12-08 02:49:04 +00:00
for (const auto idx : ext::range(0, row.fieldCount()))
{
2020-11-23 10:32:56 +00:00
/// TODO This is extremely slow.
const Poco::Dynamic::Var & value = row[idx];
2016-12-08 02:49:04 +00:00
if (!value.isEmpty())
{
if (description.types[idx].second)
{
ColumnNullable & column_nullable = assert_cast<ColumnNullable &>(*columns[idx]);
insertValue(column_nullable.getNestedColumn(), description.types[idx].first, value);
column_nullable.getNullMapData().emplace_back(0);
}
else
insertValue(*columns[idx], description.types[idx].first, value);
}
else
insertDefaultValue(*columns[idx], *description.sample_block.getByPosition(idx).column);
}
2016-12-08 02:49:04 +00:00
++iterator;
++num_rows;
if (num_rows == max_block_size)
break;
}
2016-12-08 02:49:04 +00:00
return description.sample_block.cloneWithColumns(std::move(columns));
2016-12-08 02:49:04 +00:00
}
}