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


std::swap(create.as_database, as_database_saved);
    std::swap(create.as_table, as_table_saved);
    return properties;
}
void InterpreterCreateQuery::validateTableStructure(const ASTCreateQuery & create,
                                                    const InterpreterCreateQuery::TableProperties & properties) const
{
    
    std::set<String> all_columns;
    for (const auto & column : properties.columns)
    {
        if (!all_columns.emplace(column.name).second)
            throw Exception("Column " + backQuoteIfNeed(column.name) + " already exists", ErrorCodes::DUPLICATE_COLUMN);
    }
    const auto & settings = getContext()->getSettingsRef();
    
    if (!create.attach && !settings.allow_suspicious_low_cardinality_types && !create.is_materialized_view)
    {
        for (const auto & name_and_type_pair : properties.columns.getAllPhysical())
        {
            if (const auto * current_type_ptr = typeid_cast<const DataTypeLowCardinality *>(name_and_type_pair.type.get()))
            {
                if (!isStringOrFixedString(*removeNullable(current_type_ptr->getDictionaryType())))
                    throw Exception("Creating columns of type " + current_type_ptr->getName() + " is prohibited by default "
                                    "due to expected negative impact on performance. "
                                    "It can be enabled with the \"allow_suspicious_low_cardinality_types\" setting.",
                                    ErrorCodes::SUSPICIOUS_TYPE_FOR_LOW_CARDINALITY);
            }
        }
    }