diff --git a/src/Interpreters/ExpressionAnalyzer.cpp b/src/Interpreters/ExpressionAnalyzer.cpp
index 9e7645b51f8..c2d414d7c33 100644
--- a/src/Interpreters/ExpressionAnalyzer.cpp
+++ b/src/Interpreters/ExpressionAnalyzer.cpp
@@ -115,71 +115,60 @@ bool checkPositionalArguments(ASTPtr & argument, const ASTSelectQuery * select_q
         }
     }
 
-    /// In case of expression/function (order by 1+2 and 2*x1, greatest(1, 2)) replace
-    /// positions only if all literals are numbers, otherwise it is not positional.
+    const auto * ast_literal = typeid_cast<const ASTLiteral *>(argument.get());
+    if (!ast_literal)
+        return false;
 
-    /// Case when GROUP BY element is position.
-    if (const auto * ast_literal = typeid_cast<const ASTLiteral *>(argument.get()))
+    auto which = ast_literal->value.getType();
+    if (which != Field::Types::UInt64)
+        return false;
+
+    auto pos = ast_literal->value.get<UInt64>();
+    if (!pos || pos > columns.size())
+        throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                "Positional argument out of bounds: {} (exprected in range [1, {}]",
+                        pos, columns.size());
+
+    const auto & column = columns[--pos];
+    if (typeid_cast<const ASTIdentifier *>(column.get()))
     {
-        auto which = ast_literal->value.getType();
-        if (which == Field::Types::UInt64)
+        argument = column->clone();
+    }
+    else if (typeid_cast<const ASTFunction *>(column.get()))
+    {
+        std::function<void(ASTPtr)> throw_if_aggregate_function = [&](ASTPtr node)
         {
-            auto pos = ast_literal->value.get<UInt64>();
-            if (pos > 0 && pos <= columns.size())
+            if (const auto * function = typeid_cast<const ASTFunction *>(node.get()))
             {
-                const auto & column = columns[--pos];
-                if (typeid_cast<const ASTIdentifier *>(column.get()))
+                auto is_aggregate_function = AggregateFunctionFactory::instance().isAggregateFunctionName(function->name);
+                if (is_aggregate_function)
                 {
-                    argument = column->clone();
-                }
-                else if (typeid_cast<const ASTFunction *>(column.get()))
-                {
-                    std::function<void(ASTPtr)> throw_if_aggregate_function = [&](ASTPtr node)
-                    {
-                        if (const auto * function = typeid_cast<const ASTFunction *>(node.get()))
-                        {
-                            auto is_aggregate_function = AggregateFunctionFactory::instance().isAggregateFunctionName(function->name);
-                            if (is_aggregate_function)
-                            {
-                                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                                                "Illegal value (aggregate function) for positional argument in {}",
-                                                ASTSelectQuery::expressionToString(expression));
-                            }
-                            else
-                            {
-                                if (function->arguments)
-                                {
-                                    for (const auto & arg : function->arguments->children)
-                                        throw_if_aggregate_function(arg);
-                                }
-                            }
-                        }
-                    };
-
-                    if (expression == ASTSelectQuery::Expression::GROUP_BY)
-                        throw_if_aggregate_function(column);
-
-                    argument = column->clone();
+                    throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                                    "Illegal value (aggregate function) for positional argument in {}",
+                                    ASTSelectQuery::expressionToString(expression));
                 }
                 else
                 {
-                    throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                                    "Illegal value for positional argument in {}",
-                                    ASTSelectQuery::expressionToString(expression));
+                    if (function->arguments)
+                    {
+                        for (const auto & arg : function->arguments->children)
+                            throw_if_aggregate_function(arg);
+                    }
                 }
             }
-            else if (pos > columns.size() || !pos)
-            {
-                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                     "Positional argument out of bounds: {} (exprected in range [1, {}]",
-                                pos, columns.size());
-            }
-        }
-        else
-            return false;
+        };
+
+        if (expression == ASTSelectQuery::Expression::GROUP_BY)
+            throw_if_aggregate_function(column);
+
+        argument = column->clone();
     }
     else
-        return false;
+    {
+        throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                        "Illegal value for positional argument in {}",
+                        ASTSelectQuery::expressionToString(expression));
+    }
 
     return true;
 }