Move all expression related structs to Tarantool's backend

[kyukhin]

One of biggest parts which still live in legacy DD of SQL are structures which
deal with expressions. They're:

• struct Expr
• struct ExprList
• struct ExprSpan

Expr is used by:

• struct Table to store CHECK constraints. This should be moved to struct space
• struct Column to store default value for table's column. Probably, this should be moved to struct key_def
• struct Index to store WHERE clause for partial index. Probably should be moved to struct index.
• struct Index to store functional index expression. E.g. if we're indexing on (a*a) field. Should go to struct index as well.

[kyukhin]

F-2-f discussion:

1. Need to understand if Exprs in DEFAULT can contain sub-queries
2. High level plan: clean-up/refactor struct Expr, then integrate into Tarantool
3. FOR EACH ROW constraints should be stored in Tarantool structs and ultimately invoked in Tarantool's triggers, not in VDBE
4. FK constraints should be checked by VDBE, but stored in Tarantool

[kyukhin]

Let's start from integration of default column attribute into Tarantool core.
The default value is supposed to be executed from any execution environment:
either Lua or SQL and perform AST invocation by VDBE instance.

Proposed changes:

1. Add two new fields to struct field_def:
   a) default_type. Type of default expression, string type. The only possible value so far:
   sql
   b) default_value. Default expression itself, string type. Should contain string expression
   to be compiled into AST and used when performing default insert. Example: date() * time()
2. Add single field to struct tuple_field: default, type struct Expr. This field should
   store compiled AST and VDBE executor should be invoked each time when default value
   is needed.

[kyukhin]

The main part of this issue is exposing expressions-related parts of parser to Tarantool's core.
I.e. make it possible to store SQL expression (string value) in, say, field_def structure and during
preparation of tuple_fieldto be able to translate it into AST, struct Expr *.
This AST can be used during byte code generation if, say, a default value is to be inserted.

Need to introduce a flag which will tell to parser, that all is needed is AST, no bytecode should be
emitted. This flag should also signal that no name resolution should be performed: default
expression is parsed during DDL and struct space* is not exists so far. Name resolution
should be performed later on.
The context of expression is really not wide: only constants and built-in functions are allowed
for DEFAULT and only table under construction columns for CHECK constraint. Hence,
approach would be:

1. Introduce a flag signalling that no name resolution to be performed by parser and no byte-code
   to be emitted
2. Convert expression string to "SELECT " and invoke the parser
3. Find parsed struct Expr* in result struct Select* or report error

This approach should work also for CHECK constraints and maybe partial indexes.

[Gerold103]

There is no struct Select * if you only parse. You should get only ExprList in parser struct. When struct Select * is generated, it resolves names, that is not needed. In fact, you should stop the parser before it starts search FROM clause.

[Korablev77]

After all, the only artefact remained is struct Table, struct Index and struct Column don't exist anymore. Despite removing table hash, struct Table is still used as a wrapper around struct space and appears for example in struct SrcList.