new alias for current_database and added current_schemas

src/Functions/currentDatabase.cpp

@@ -54,7 +54,8 @@ public:
 REGISTER_FUNCTION(CurrentDatabase)
 {
     factory.registerFunction<FunctionCurrentDatabase>();
-    factory.registerAlias("DATABASE", "currentDatabase", FunctionFactory::CaseInsensitive);
+    factory.registerAlias("DATABASE", FunctionCurrentDatabase::name, FunctionFactory::CaseInsensitive);
+    factory.registerAlias("current_database", FunctionCurrentDatabase::name, FunctionFactory::CaseInsensitive);
 }
 
 }

src/Functions/currentSchemas.cpp

@@ -0,0 +1,88 @@
+#include <Functions/IFunction.h>
+#include <Functions/FunctionFactory.h>
+#include <Interpreters/Context.h>
+#include <DataTypes/DataTypeArray.h>
+#include <DataTypes/DataTypeString.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+}
+
+namespace
+{
+
+class FunctionCurrentSchemas : public IFunction
+{
+    const String db_name;
+
+public:
+    static constexpr auto name = "currentSchemas";
+    static FunctionPtr create(ContextPtr context)
+    {
+        return std::make_shared<FunctionCurrentSchemas>(context->getCurrentDatabase());
+    }
+
+    explicit FunctionCurrentSchemas(const String & db_name_) :
+        db_name{db_name_}
+    {
+    }
+
+    String getName() const override
+    {
+        return name;
+    }
+
+    size_t getNumberOfArguments() const override
+    {
+        return 1;
+    }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
+    {
+        // For compatibility, function implements the same signature as Postgres'
+        const bool argument_is_valid = arguments.size() == 1 && isBool(arguments.front());
+        if (!argument_is_valid)
+            throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Argument for function {} must be bool", getName());
+
+        return std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>());
+    }
+
+    bool isDeterministic() const override { return false; }
+
+    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; }
+
+    ColumnPtr executeImpl(const ColumnsWithTypeAndName &, const DataTypePtr &, size_t input_rows_count) const override
+    {
+        return DataTypeArray(std::make_shared<DataTypeString>())
+                               .createColumnConst(input_rows_count, Array { db_name });
+    }
+};
+
+}
+
+REGISTER_FUNCTION(CurrentSchema)
+{
+    factory.registerFunction<FunctionCurrentSchemas>(FunctionDocumentation
+         {
+             .description=R"(
+Returns a single-element array with the name of the current database
+
+Requires a boolean parameter, but it is ignored actually. It is required just for compatibility with the implementation of this function in other DB engines.
+
+[example:common]
+)",
+            .examples{
+             {"common", "SELECT current_schemas(true);", "['default']"}
+        }
+        },
+        FunctionFactory::CaseInsensitive);
+    factory.registerAlias("current_schemas", FunctionCurrentSchemas::name, FunctionFactory::CaseInsensitive);
+
+}
+
+}

tests/queries/0_stateless/02788_current_schemas_function.reference

@@ -0,0 +1,2 @@
+['default']
+['default']

tests/queries/0_stateless/02788_current_schemas_function.sql

@@ -0,0 +1,4 @@
+SELECT current_schemas(true) AS result;
+SELECT current_schemas(false) AS result;
+SELECT current_schemas(1); -- { serverError 43 }
+SELECT current_schemas(); -- { serverError 42 }