Execution of this query
```
create table t (c1 int(11) DEFAULT 1 NULL) engine=MergeTree order by tuple()
```
will return parsed query
```
CREATE TABLE t
(
     `c1` int NULL DEFAULT 1
)
ENGINE = MergeTree
ORDER BY tuple()
```
In the parsed query, NULL comes before DEFAULT, in the initial - other way around.
If I try to execute the parsed query, I’ll get the following error:
```
Syntax error: failed at position 36 ('DEFAULT') (line 3, col 19):

CREATE TABLE t
(
    `c1` int NULL DEFAULT 1
)
ENGINE = MergeTree
ORDER BY tuple()

Expected one of: COMMENT, CODEC, TTL, token, Comma, ClosingRoundBracket
```
This is confusing. 
See also discussion in #37087

Considerations:
(1) considering simplification of migration from other databases (see, for example, #37178) probably it makes sense to keep support for old column declaration, - MySQL supports both ways: `NULL DEFAULT 1` and `DEFAULT 1 NULL`, even `COMMENT '1' NULL` which we don't support. This way it'll keep the change backward compatible
(2) from another side ... I guess ... there is no target to support all variants of different syntax. It's not desirable to complicate parser implementation just for this reason


const ASTExpressionList & columns_ast, ContextPtr context_, bool attach)
{
    
    /** all default_expressions as a single expression list,
     *  mixed with conversion-columns for each explicitly specified type */
    ASTPtr default_expr_list = std::make_shared<ASTExpressionList>();
    NamesAndTypesList column_names_and_types;
    bool make_columns_nullable = !attach && context_->getSettingsRef().data_type_default_nullable;
    for (const auto & ast : columns_ast.children)
    {
        const auto & col_decl = ast->as<ASTColumnDeclaration &>();
        if (col_decl.collation && !context_->getSettingsRef().compatibility_ignore_collation_in_create_table)
        {
            throw Exception("Cannot support collation, please set compatibility_ignore_collation_in_create_table=true", ErrorCodes::NOT_IMPLEMENTED);
        }
        DataTypePtr column_type = nullptr;
        if (col_decl.type)
        {
            column_type = DataTypeFactory::instance().get(col_decl.type);
            const auto * aggregate_function_type = typeid_cast<const DataTypeAggregateFunction *>(column_type.get());
            if (attach && aggregate_function_type && aggregate_function_type->isVersioned())
                aggregate_function_type->setVersion(0, true);
            if (col_decl.null_modifier)
            {
                if (column_type->isNullable())
                    throw Exception("Can't use [NOT] NULL modifier with Nullable type", ErrorCodes::ILLEGAL_SYNTAX_FOR_DATA_TYPE);
                if (*col_decl.null_modifier)
                    column_type = makeNullable(column_type);