ClickHouse/dbms/Parsers/IAST.h

235 lines
6.8 KiB
C++
Raw Normal View History

2011-08-09 19:19:00 +00:00
#pragma once
2010-06-24 19:12:10 +00:00
#include <Core/Types.h>
#include <Parsers/IAST_fwd.h>
#include <Parsers/IdentifierQuotingStyle.h>
#include <Common/Exception.h>
#include <Common/TypePromotion.h>
#include <algorithm>
#include <ostream>
#include <set>
2010-06-24 19:12:10 +00:00
class SipHash;
2010-06-24 19:12:10 +00:00
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_A_COLUMN;
extern const int UNKNOWN_TYPE_OF_AST_NODE;
extern const int UNKNOWN_ELEMENT_IN_AST;
extern const int LOGICAL_ERROR;
}
using IdentifierNameSet = std::set<String>;
2010-06-24 19:12:10 +00:00
class WriteBuffer;
2010-06-24 19:12:10 +00:00
2017-05-27 17:29:55 +00:00
/** Element of the syntax tree (hereinafter - directed acyclic graph with elements of semantics)
2010-06-24 19:12:10 +00:00
*/
class IAST : public std::enable_shared_from_this<IAST>, public TypePromotion<IAST>
2011-08-13 21:05:18 +00:00
{
2010-06-24 19:12:10 +00:00
public:
ASTs children;
virtual ~IAST() = default;
IAST() = default;
IAST(const IAST &) = default;
IAST & operator=(const IAST &) = default;
2017-05-27 17:29:55 +00:00
/** Get the canonical name of the column if the element is a column */
String getColumnName() const;
virtual void appendColumnName(WriteBuffer &) const
{
throw Exception("Trying to get name of not a column: " + getID(), ErrorCodes::NOT_A_COLUMN);
}
2017-05-27 17:29:55 +00:00
/** Get the alias, if any, or the canonical name of the column, if it is not. */
virtual String getAliasOrColumnName() const { return getColumnName(); }
2017-05-27 17:29:55 +00:00
/** Get the alias, if any, or an empty string if it does not exist, or if the element does not support aliases. */
virtual String tryGetAlias() const { return String(); }
2017-05-27 17:29:55 +00:00
/** Set the alias. */
2017-12-01 18:36:55 +00:00
virtual void setAlias(const String & /*to*/)
{
throw Exception("Can't set alias of " + getColumnName(), ErrorCodes::UNKNOWN_TYPE_OF_AST_NODE);
}
2017-05-27 17:29:55 +00:00
/** Get the text that identifies this element. */
virtual String getID(char delimiter = '_') const = 0;
ASTPtr ptr() { return shared_from_this(); }
/** Get a deep copy of the tree. Cloned object must have the same range. */
virtual ASTPtr clone() const = 0;
/** Get hash code, identifying this element and its subtree.
*/
using Hash = std::pair<UInt64, UInt64>;
Hash getTreeHash() const;
void updateTreeHash(SipHash & hash_state) const;
virtual void updateTreeHashImpl(SipHash & hash_state) const;
void dumpTree(std::ostream & ostr, size_t indent = 0) const
{
String indent_str(indent, '-');
ostr << indent_str << getID() << ", " << this << std::endl;
for (const auto & child : children)
child->dumpTree(ostr, indent + 1);
}
2017-05-27 17:29:55 +00:00
/** Check the depth of the tree.
* If max_depth is specified and the depth is greater - throw an exception.
* Returns the depth of the tree.
*/
size_t checkDepth(size_t max_depth) const
{
return checkDepthImpl(max_depth, 0);
}
/** Get total number of tree elements
*/
size_t size() const;
2017-05-27 17:29:55 +00:00
/** Same for the total number of tree elements.
*/
size_t checkSize(size_t max_size) const;
2017-05-27 17:29:55 +00:00
/** Get `set` from the names of the identifiers
*/
virtual void collectIdentifierNames(IdentifierNameSet & set) const
{
for (const auto & child : children)
child->collectIdentifierNames(set);
}
template <typename T>
void set(T * & field, const ASTPtr & child)
{
if (!child)
return;
T * casted = dynamic_cast<T *>(child.get());
if (!casted)
throw Exception("Could not cast AST subtree", ErrorCodes::LOGICAL_ERROR);
children.push_back(child);
field = casted;
}
template <typename T>
void replace(T * & field, const ASTPtr & child)
{
if (!child)
throw Exception("Trying to replace AST subtree with nullptr", ErrorCodes::LOGICAL_ERROR);
T * casted = dynamic_cast<T *>(child.get());
if (!casted)
throw Exception("Could not cast AST subtree", ErrorCodes::LOGICAL_ERROR);
for (ASTPtr & current_child : children)
{
if (current_child.get() == field)
{
current_child = child;
field = casted;
return;
}
}
throw Exception("AST subtree not found in children", ErrorCodes::LOGICAL_ERROR);
}
template <typename T>
void setOrReplace(T * & field, const ASTPtr & child)
{
if (field)
replace(field, child);
else
set(field, child);
}
2017-05-27 17:29:55 +00:00
/// Convert to a string.
2017-05-27 17:29:55 +00:00
/// Format settings.
struct FormatSettings
{
std::ostream & ostr;
bool hilite = false;
bool one_line;
bool always_quote_identifiers = false;
IdentifierQuotingStyle identifier_quoting_style = IdentifierQuotingStyle::Backticks;
char nl_or_ws;
FormatSettings(std::ostream & ostr_, bool one_line_)
: ostr(ostr_), one_line(one_line_)
{
nl_or_ws = one_line ? ' ' : '\n';
}
FormatSettings(std::ostream & ostr_, const FormatSettings & other)
: ostr(ostr_), hilite(other.hilite), one_line(other.one_line),
always_quote_identifiers(other.always_quote_identifiers), identifier_quoting_style(other.identifier_quoting_style)
{
nl_or_ws = one_line ? ' ' : '\n';
}
void writeIdentifier(const String & name) const;
};
2017-05-27 17:29:55 +00:00
/// State. For example, a set of nodes can be remembered, which we already walk through.
struct FormatState
{
2017-05-27 17:29:55 +00:00
/** The SELECT query in which the alias was found; identifier of a node with such an alias.
* It is necessary that when the node has met again, output only the alias.
*/
std::set<std::tuple<
const IAST * /* SELECT query node */,
std::string /* alias */,
2019-06-30 12:49:06 +00:00
Hash /* printed content */>> printed_asts_with_alias;
};
2017-05-27 17:29:55 +00:00
/// The state that is copied when each node is formatted. For example, nesting level.
struct FormatStateStacked
{
UInt8 indent = 0;
bool need_parens = false;
const IAST * current_select = nullptr;
};
void format(const FormatSettings & settings) const
{
FormatState state;
formatImpl(settings, state, FormatStateStacked());
}
2017-12-01 18:36:55 +00:00
virtual void formatImpl(const FormatSettings & /*settings*/, FormatState & /*state*/, FormatStateStacked /*frame*/) const
{
2019-01-18 16:30:35 +00:00
throw Exception("Unknown element in AST: " + getID(), ErrorCodes::UNKNOWN_ELEMENT_IN_AST);
}
void cloneChildren();
2017-04-21 12:39:28 +00:00
public:
2017-05-27 17:29:55 +00:00
/// For syntax highlighting.
static const char * hilite_keyword;
static const char * hilite_identifier;
static const char * hilite_function;
static const char * hilite_operator;
static const char * hilite_alias;
2019-06-15 17:52:53 +00:00
static const char * hilite_substitution;
static const char * hilite_none;
private:
size_t checkDepthImpl(size_t max_depth, size_t level) const;
2010-06-24 19:12:10 +00:00
};
}