thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-09-24 02:30:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

removed ColumnExpression and DataTypeExpression [#CLICKHOUSE-3550]

Browse Source
This commit is contained in:
Nikolai Kochetov 2018-02-08 19:37:50 +03:00
parent 27179b375a
commit 64b0279af5
8 changed files with 10 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
dbms/src/Analyzers/TypeAndConstantInference.cpp
View File

@ -128,15 +128,15 @@ void processFunction(const String & column_name, ASTPtr & ast, TypeAndConstantIn
{
ASTFunction * function = static_cast<ASTFunction *>(ast.get());
/// Special case for lambda functions. Lambda function has special return type "Expression".
/// We first create info with Expression of unspecified arguments, and will specify them later.
/// Special case for lambda functions. Lambda function has special return type "Function".
/// We first create info with Function of unspecified arguments, and will specify them later.
if (function->name == "lambda")
{
size_t number_of_lambda_parameters = AnalyzeLambdas::extractLambdaParameters(function->arguments->children.at(0)).size();
TypeAndConstantInference::ExpressionInfo expression_info;
expression_info.node = ast;
expression_info.data_type = std::make_unique<DataTypeExpression>(DataTypes(number_of_lambda_parameters));
expression_info.data_type = std::make_unique<DataTypeFunction>(DataTypes(number_of_lambda_parameters));
info.emplace(column_name, std::move(expression_info));
return;
}

25
dbms/src/Columns/ColumnExpression.cpp
View File

@ -1,25 +0,0 @@
#include <Interpreters/ExpressionActions.h>
#include <Columns/ColumnExpression.h>
namespace DB
{
ColumnExpression::ColumnExpression(
size_t s_, const ExpressionActionsPtr & expression_, const NamesAndTypesList & arguments_, const DataTypePtr & return_type_, const String & return_name_)
: expression(expression_), arguments(arguments_), return_type(return_type_), return_name(return_name_)
{
s = s_;
}
MutableColumnPtr ColumnExpression::cloneDummy(size_t s_) const
{
return ColumnExpression::create(s_, expression, arguments, return_type, return_name);
}
const ExpressionActionsPtr & ColumnExpression::getExpression() const { return expression; }
const DataTypePtr & ColumnExpression::getReturnType() const { return return_type; }
const std::string & ColumnExpression::getReturnName() const { return return_name; }
const NamesAndTypesList & ColumnExpression::getArguments() const { return arguments; }
}

41
dbms/src/Columns/ColumnExpression.h
View File

@ -1,41 +0,0 @@
#pragma once
#include <Core/NamesAndTypes.h>
#include <Columns/IColumnDummy.h>
namespace DB
{
class ExpressionActions;
/** A column containing a lambda expression.
* Behaves like a constant-column. Contains an expression, but not input or output data.
*/
class ColumnExpression final : public COWPtrHelper<IColumnDummy, ColumnExpression>
{
private:
friend class COWPtrHelper<IColumnDummy, ColumnExpression>;
using ExpressionActionsPtr = std::shared_ptr<ExpressionActions>;
ColumnExpression(size_t s_, const ExpressionActionsPtr & expression_, const NamesAndTypesList & arguments_, const DataTypePtr & return_type_, const String & return_name_);
ColumnExpression(const ColumnExpression &) = default;
public:
const char * getFamilyName() const override { return "Expression"; }
MutableColumnPtr cloneDummy(size_t s_) const override;
const ExpressionActionsPtr & getExpression() const;
const DataTypePtr & getReturnType() const;
const std::string & getReturnName() const;
const NamesAndTypesList & getArguments() const;
private:
ExpressionActionsPtr expression;
NamesAndTypesList arguments;
DataTypePtr return_type;
std::string return_name;
};
}

32
dbms/src/DataTypes/DataTypeExpression.cpp
View File

@ -1,32 +0,0 @@
#include <DataTypes/DataTypeExpression.h>
namespace DB
{
std::string DataTypeExpression::getName() const
{
std::string res = "Expression(";
if (argument_types.size() > 1)
res += "(";
for (size_t i = 0; i < argument_types.size(); ++i)
{
if (i > 0)
res += ", ";
const DataTypePtr & type = argument_types[i];
res += type ? type->getName() : "?";
}
if (argument_types.size() > 1)
res += ")";
res += " -> ";
res += return_type ? return_type->getName() : "?";
res += ")";
return res;
}
bool DataTypeExpression::equals(const IDataType & rhs) const
{
return typeid(rhs) == typeid(*this) && getName() == rhs.getName();
}
}

41
dbms/src/DataTypes/DataTypeExpression.h
View File

@ -1,41 +0,0 @@
#pragma once
#include <DataTypes/IDataTypeDummy.h>
namespace DB
{
/** Special data type, representing lambda expression.
*/
class DataTypeExpression final : public IDataTypeDummy
{
private:
DataTypes argument_types;
DataTypePtr return_type;
public:
static constexpr bool is_parametric = true;
bool isParametric() const override { return true; }
/// Some types could be still unknown.
DataTypeExpression(const DataTypes & argument_types_ = DataTypes(), const DataTypePtr & return_type_ = nullptr)
: argument_types(argument_types_), return_type(return_type_) {}
std::string getName() const override;
const char * getFamilyName() const override { return "Expression"; }
const DataTypes & getArgumentTypes() const
{
return argument_types;
}
const DataTypePtr & getReturnType() const
{
return return_type;
}
bool equals(const IDataType & rhs) const override;
};
}

2
dbms/src/Functions/FunctionsHigherOrder.h
View File

@ -1,13 +1,11 @@
#pragma once
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeExpression.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/ExpressionActions.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnConst.h>
#include <Columns/ColumnExpression.h>
#include <Common/typeid_cast.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionsMiscellaneous.h>

33
dbms/src/Functions/FunctionsMiscellaneous.h
View File

@ -10,32 +10,7 @@
namespace DB
{
/** Creates an array, multiplying the column (the first argument) by the number of elements in the array (the second argument).
* Used only as prerequisites for higher-order functions.
*/
class FunctionReplicate : public IFunction
{
public:
static constexpr auto name = "replicate";
static FunctionPtr create(const Context & context);
String getName() const override
{
return name;
}
size_t getNumberOfArguments() const override
{
return 2;
}
bool useDefaultImplementationForNulls() const override { return false; }
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
};
/// Executes expression. Uses for lambda functions implementation. Isn't can't be created from factory.
class FunctionExpression : public IFunctionBase, public IPreparedFunction,
public std::enable_shared_from_this<FunctionExpression>
{
@ -64,6 +39,7 @@ public:
for (size_t i = 0; i < arguments.size(); ++i)
{
const auto & argument = block.getByPosition(arguments[i]);
/// Replace column name with value from argument_names.
expr_block.insert({argument.column, argument.type, argument_names[i]});
}
@ -80,6 +56,10 @@ private:
std::string return_name;
};
/// Captures columns which are used bu lambda function but not in argument list.
/// Returns ColumnFunction with captured columns.
/// For lambda(x, x + y) x is in lambda_arguments, y is in captured arguments, expression_actions is 'x + y'.
/// execute(y) returns ColumnFunction(FunctionExpression(x + y), y) with type Function(x) -> function_return_type.
class FunctionCapture : public IFunctionBase, public IPreparedFunction, public FunctionBuilderImpl,
public std::enable_shared_from_this<FunctionCapture>
{
@ -91,6 +71,7 @@ public:
, function_return_type(function_return_type), expression_return_name(expression_return_name)
{
const auto & all_arguments = expression_actions->getRequiredColumnsWithTypes();
std::unordered_map<std::string, DataTypePtr> arguments_map;
for (const auto & arg : all_arguments)
arguments_map[arg.name] = arg.type;

2
dbms/src/Interpreters/ExpressionAnalyzer.cpp
View File

@ -17,12 +17,10 @@
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeExpression.h>
#include <DataTypes/NestedUtils.h>
#include <DataTypes/DataTypesNumber.h>
#include <Columns/ColumnSet.h>
#include <Columns/ColumnExpression.h>
#include <Columns/ColumnConst.h>
#include <Interpreters/InterpreterSelectQuery.h>