First step to support PG in olap. (#2818)

11 files changed, 219 insertions, 45 deletions

diff --git a/ydb/core/formats/arrow/switch/switch_type.h b/ydb/core/formats/arrow/switch/switch_type.h
index a8627f4654c..9db9a8acb99 100644
--- a/ydb/core/formats/arrow/switch/switch_type.h
+++ b/ydb/core/formats/arrow/switch/switch_type.h
@@ -2,10 +2,15 @@
 #include <ydb/core/scheme_types/scheme_type_info.h>
 #include <ydb/core/scheme/scheme_type_id.h>
 #include <ydb/core/formats/arrow/common/validation.h>
+#include <ydb/library/yql/parser/pg_wrapper/interface/type_desc.h>
 
 #include <contrib/libs/apache/arrow/cpp/src/arrow/api.h>
 #include <util/system/yassert.h>
 
+extern "C" {
+#include <ydb/library/yql/parser/pg_wrapper/postgresql/src/include/catalog/pg_type_d.h>
+}
+
 namespace NKikimr::NArrow {
 
 template <typename TType>
@@ -166,6 +171,24 @@ bool SwitchYqlTypeToArrowType(const NScheme::TTypeInfo& typeInfo, TFunc&& callba
             break; // Deprecated types
 
         case NScheme::NTypeIds::Pg:
+            switch (NPg::PgTypeIdFromTypeDesc(typeInfo.GetTypeDesc())) {
+                case INT2OID:
+                    return callback(TTypeWrapper<arrow::Int16Type>());
+                case INT4OID:
+                    return callback(TTypeWrapper<arrow::Int32Type>());
+                case INT8OID:
+                    return callback(TTypeWrapper<arrow::Int64Type>());
+                case FLOAT4OID:
+                    return callback(TTypeWrapper<arrow::FloatType>());
+                case FLOAT8OID:
+                    return callback(TTypeWrapper<arrow::DoubleType>());
+                case BYTEAOID:
+                    return callback(TTypeWrapper<arrow::BinaryType>());
+                case TEXTOID:
+                    return callback(TTypeWrapper<arrow::StringType>());
+                default:
+                    break;
+            }
             break; // TODO: support pg types
     }
     return false;
diff --git a/ydb/core/kqp/executer_actor/kqp_executer_impl.h b/ydb/core/kqp/executer_actor/kqp_executer_impl.h
index 1561439a45f..5755964dc6c 100644
--- a/ydb/core/kqp/executer_actor/kqp_executer_impl.h
+++ b/ydb/core/kqp/executer_actor/kqp_executer_impl.h
@@ -1386,15 +1386,20 @@ protected:
 
             taskMeta.ReadInfo.ResultColumnsTypes.reserve(resultColsCount);
             for (ui32 i = 0; i < resultColsCount; ++i) {
+                taskMeta.ReadInfo.ResultColumnsTypes.emplace_back();
                 auto memberType = resultStructType->GetMemberType(i);
-                if (memberType->GetKind() == NKikimr::NMiniKQL::TType::EKind::Optional) {
-                    memberType = static_cast<NKikimr::NMiniKQL::TOptionalType*>(memberType)->GetItemType();
+                if (memberType->GetKind() == NKikimr::NMiniKQL::TType::EKind::Pg) {
+                    const auto memberPgType = static_cast<NKikimr::NMiniKQL::TPgType*>(memberType);
+                    taskMeta.ReadInfo.ResultColumnsTypes.back() = NScheme::TTypeInfo(NScheme::NTypeIds::Pg, NPg::TypeDescFromPgTypeId(memberPgType->GetTypeId()));
+                } else {
+                    if (memberType->GetKind() == NKikimr::NMiniKQL::TType::EKind::Optional) {
+                        memberType = static_cast<NKikimr::NMiniKQL::TOptionalType*>(memberType)->GetItemType();
+                    }
+                    YQL_ENSURE(memberType->GetKind() == NKikimr::NMiniKQL::TType::EKind::Data,
+                        "Expected simple data types to be read from column shard");
+                    const auto memberDataType = static_cast<NKikimr::NMiniKQL::TDataType*>(memberType);
+                    taskMeta.ReadInfo.ResultColumnsTypes.back() = NScheme::TTypeInfo(memberDataType->GetSchemeType());
                 }
-                // TODO: support pg types
-                YQL_ENSURE(memberType->GetKind() == NKikimr::NMiniKQL::TType::EKind::Data,
-                    "Expected simple data types to be read from column shard");
-                auto memberDataType = static_cast<NKikimr::NMiniKQL::TDataType*>(memberType);
-                taskMeta.ReadInfo.ResultColumnsTypes.push_back(NScheme::TTypeInfo(memberDataType->GetSchemeType()));
             }
         }
         if (!readOlapRange || readOlapRange->GetOlapProgram().empty()) {
diff --git a/ydb/core/kqp/provider/yql_kikimr_exec.cpp b/ydb/core/kqp/provider/yql_kikimr_exec.cpp
index 1eb5af3e2e6..eb29544a642 100644
--- a/ydb/core/kqp/provider/yql_kikimr_exec.cpp
+++ b/ydb/core/kqp/provider/yql_kikimr_exec.cpp
@@ -199,15 +199,20 @@ namespace {
             auto columnType = typeNode.Ref().GetTypeAnn();
             YQL_ENSURE(columnType && columnType->GetKind() == ETypeAnnotationKind::Type);
 
-            auto type = columnType->Cast<TTypeExprType>()->GetType();
-            auto notNull = type->GetKind() != ETypeAnnotationKind::Optional;
-            auto actualType = notNull ? type : type->Cast<TOptionalExprType>()->GetItemType();
-            auto dataType = actualType->Cast<TDataExprType>();
-
+            const auto type = columnType->Cast<TTypeExprType>()->GetType();
             TKikimrColumnMetadata columnMeta;
             columnMeta.Name = columnName;
-            columnMeta.Type = dataType->GetName();
-            columnMeta.NotNull = notNull;
+            if (ETypeAnnotationKind::Pg == type->GetKind()) {
+                const auto pgType = type->Cast<TPgExprType>();
+                columnMeta.Type = TString("pg") += pgType->GetName();
+                columnMeta.NotNull = false;
+            } else {
+                const auto notNull = type->GetKind() != ETypeAnnotationKind::Optional;
+                const auto actualType = notNull ? type : type->Cast<TOptionalExprType>()->GetItemType();
+                const auto dataType = actualType->Cast<TDataExprType>();
+                columnMeta.Type = dataType->GetName();
+                columnMeta.NotNull = notNull;
+            }
 
             out.ColumnOrder.push_back(columnName);
             out.Columns.insert(std::make_pair(columnName, columnMeta));
diff --git a/ydb/core/kqp/runtime/kqp_scan_data.cpp b/ydb/core/kqp/runtime/kqp_scan_data.cpp
index 7e8ef778f75..cb851182756 100644
--- a/ydb/core/kqp/runtime/kqp_scan_data.cpp
+++ b/ydb/core/kqp/runtime/kqp_scan_data.cpp
@@ -399,9 +399,22 @@ TBytesStatistics WriteColumnValuesFromArrowImpl(TAccessor editAccessor,
             return WriteColumnValuesFromArrowSpecImpl<TElementAccessor<arrow::FixedSizeBinaryArray, NUdf::TStringRef>>(editAccessor, batch, columnIndex, columnPtr, columnType);
         }
         case NTypeIds::Pg:
+            switch (NPg::PgTypeIdFromTypeDesc(columnType.GetTypeDesc())) {
+                case INT2OID:
+                    return WriteColumnValuesFromArrowSpecImpl<TElementAccessor<arrow::Int16Array>>(editAccessor, batch, columnIndex, columnPtr, columnType);
+                case INT4OID:
+                    return WriteColumnValuesFromArrowSpecImpl<TElementAccessor<arrow::Int32Array>>(editAccessor, batch, columnIndex, columnPtr, columnType);
+                case INT8OID:
+                    return WriteColumnValuesFromArrowSpecImpl<TElementAccessor<arrow::Int64Array, i64>>(editAccessor, batch, columnIndex, columnPtr, columnType);
+                case FLOAT4OID:
+                    return WriteColumnValuesFromArrowSpecImpl<TElementAccessor<arrow::FloatArray>>(editAccessor, batch, columnIndex, columnPtr, columnType);
+                case FLOAT8OID:
+                    return WriteColumnValuesFromArrowSpecImpl<TElementAccessor<arrow::DoubleArray>>(editAccessor, batch, columnIndex, columnPtr, columnType);
+                default:
+                    break;
+            }
             // TODO: support pg types
             YQL_ENSURE(false, "Unsupported pg type at column " << columnIndex);
-
         default:
             YQL_ENSURE(false, "Unsupported type: " << NScheme::TypeName(columnType.GetTypeId()) << " at column " << columnIndex);
     }
diff --git a/ydb/core/kqp/ut/common/columnshard.cpp b/ydb/core/kqp/ut/common/columnshard.cpp
index 5afd2d71eaf..7fcafc47d43 100644
--- a/ydb/core/kqp/ut/common/columnshard.cpp
+++ b/ydb/core/kqp/ut/common/columnshard.cpp
@@ -1,6 +1,10 @@
 #include "columnshard.h"
 #include <ydb/core/testlib/cs_helper.h>
 
+extern "C" {
+#include <ydb/library/yql/parser/pg_wrapper/postgresql/src/include/catalog/pg_type_d.h>
+}
+
 namespace NKikimr {
 namespace NKqp {
 
@@ -125,16 +129,20 @@ namespace NKqp {
         }
     }
 
-
     TString TTestHelper::TColumnSchema::BuildQuery() const {
-        auto str = TStringBuilder() << Name << " " << NScheme::GetTypeName(Type);
+        TStringBuilder str;
+        str << Name << ' ';
+        if (NScheme::NTypeIds::Pg == Type) {
+            str << NPg::PgTypeNameFromTypeDesc(TypeDesc);
+        } else {
+            str << NScheme::GetTypeName(Type);
+        }
         if (!NullableFlag) {
             str << " NOT NULL";
         }
         return str;
     }
 
-
     TString TTestHelper::TColumnTableBase::BuildQuery() const {
         auto str = TStringBuilder() << "CREATE " << GetObjectType() << " `" << Name << "`";
         str << " (" << BuildColumnsStr(Schema) << ", PRIMARY KEY (" << JoinStrings(PrimaryKey, ", ") << "))";
@@ -154,7 +162,7 @@ namespace NKqp {
     std::shared_ptr<arrow::Schema> TTestHelper::TColumnTableBase::GetArrowSchema(const TVector<TColumnSchema>& columns) {
         std::vector<std::shared_ptr<arrow::Field>> result;
         for (auto&& col : columns) {
-            result.push_back(BuildField(col.GetName(), col.GetType(), col.IsNullable()));
+            result.push_back(BuildField(col.GetName(), col.GetType(), col.GetTypeDesc(), col.IsNullable()));
         }
         return std::make_shared<arrow::Schema>(result);
     }
@@ -168,8 +176,7 @@ namespace NKqp {
         return JoinStrings(columnStr, ", ");
     }
 
-
-    std::shared_ptr<arrow::Field> TTestHelper::TColumnTableBase::BuildField(const TString name, const NScheme::TTypeId& typeId, bool nullable) const {
+    std::shared_ptr<arrow::Field> TTestHelper::TColumnTableBase::BuildField(const TString name, const NScheme::TTypeId typeId, void*const typeDesc, bool nullable) const {
         switch (typeId) {
         case NScheme::NTypeIds::Bool:
             return arrow::field(name, arrow::boolean(), nullable);
@@ -211,11 +218,29 @@ namespace NKqp {
             return arrow::field(name, arrow::duration(arrow::TimeUnit::TimeUnit::MICRO), nullable);
         case NScheme::NTypeIds::JsonDocument:
             return arrow::field(name, arrow::binary(), nullable);
+        case NScheme::NTypeIds::Pg:
+            switch (NPg::PgTypeIdFromTypeDesc(typeDesc)) {
+                case INT2OID:
+                    return arrow::field(name, arrow::int16(), true);
+                case INT4OID:
+                    return arrow::field(name, arrow::int32(), true);
+                case INT8OID:
+                    return arrow::field(name, arrow::int64(), true);
+                case FLOAT4OID:
+                    return arrow::field(name, arrow::float32(), true);
+                case FLOAT8OID:
+                    return arrow::field(name, arrow::float64(), true);
+                case BYTEAOID:
+                    return arrow::field(name, arrow::binary(), true);
+                case TEXTOID:
+                    return arrow::field(name, arrow::utf8(), true);
+                default:
+                    Y_FAIL("TODO: support pg");
+            }
         }
         return nullptr;
     }
 
-
     TString TTestHelper::TColumnTable::GetObjectType() const {
         return "TABLE";
     }
diff --git a/ydb/core/kqp/ut/common/columnshard.h b/ydb/core/kqp/ut/common/columnshard.h
index 2ac738be7cd..34046f1b110 100644
--- a/ydb/core/kqp/ut/common/columnshard.h
+++ b/ydb/core/kqp/ut/common/columnshard.h
@@ -18,8 +18,10 @@ namespace NKqp {
     class TTestHelper {
     public:
         class TColumnSchema {
+            using TTypeDesc = void*;
             YDB_ACCESSOR_DEF(TString, Name);
             YDB_ACCESSOR_DEF(NScheme::TTypeId, Type);
+            YDB_ACCESSOR_DEF(TTypeDesc, TypeDesc);
             YDB_FLAG_ACCESSOR(Nullable, true);
         public:
             TString BuildQuery() const;
@@ -47,7 +49,7 @@ namespace NKqp {
         private:
             virtual TString GetObjectType() const = 0;
             TString BuildColumnsStr(const TVector<TColumnSchema>& clumns) const;
-            std::shared_ptr<arrow::Field> BuildField(const TString name, const NScheme::TTypeId& typeId, bool nullable) const;
+            std::shared_ptr<arrow::Field> BuildField(const TString name, const NScheme::TTypeId typeId, void*const typeDesc, bool nullable) const;
         };
 
         class TColumnTable : public TColumnTableBase {
diff --git a/ydb/core/kqp/ut/scheme/kqp_scheme_ut.cpp b/ydb/core/kqp/ut/scheme/kqp_scheme_ut.cpp
index ea4765c9b3a..365edcdec0d 100644
--- a/ydb/core/kqp/ut/scheme/kqp_scheme_ut.cpp
+++ b/ydb/core/kqp/ut/scheme/kqp_scheme_ut.cpp
@@ -5651,6 +5651,70 @@ Y_UNIT_TEST_SUITE(KqpOlapScheme) {
         testHelper.ReadData("SELECT new_column FROM `/Root/TableStoreTest/ColumnTableTest`", "[[#];[#];[[200u]]]");
     }
 
+    Y_UNIT_TEST(AddPgColumnWithStore) {
+        TKikimrSettings runnerSettings;
+        runnerSettings.WithSampleTables = false;
+        TTestHelper testHelper(runnerSettings);
+
+        TVector<TTestHelper::TColumnSchema> schema = {
+            TTestHelper::TColumnSchema().SetName("id").SetType(NScheme::NTypeIds::Int32).SetNullable(false),
+            TTestHelper::TColumnSchema().SetName("resource_id").SetType(NScheme::NTypeIds::Utf8),
+            TTestHelper::TColumnSchema().SetName("level").SetType(NScheme::NTypeIds::Pg).SetTypeDesc(NPg::TypeDescFromPgTypeName("pgint4"))
+        };
+        TTestHelper::TColumnTableStore testTableStore;
+
+        testTableStore.SetName("/Root/TableStoreTest").SetPrimaryKey({"id"}).SetSchema(schema);
+        testHelper.CreateTable(testTableStore);
+        TTestHelper::TColumnTable testTable;
+        testTable.SetName("/Root/TableStoreTest/ColumnTableTest").SetPrimaryKey({"id"}).SetSharding({"id"}).SetSchema(schema);
+        testHelper.CreateTable(testTable);
+
+        {
+            TTestHelper::TUpdatesBuilder tableInserter(testTable.GetArrowSchema(schema));
+            tableInserter.AddRow().Add(1).Add("test_res_1").AddNull();
+            tableInserter.AddRow().Add(2).Add("test_res_2").Add(-123);
+            testHelper.BulkUpsert(testTable, tableInserter);
+        }
+
+        testHelper.ReadData("SELECT * FROM `/Root/TableStoreTest/ColumnTableTest` WHERE id=1", "[[1;#;[\"test_res_1\"]]]");
+
+        {
+            schema.push_back(TTestHelper::TColumnSchema().SetName("new_column").SetType(NScheme::NTypeIds::Pg).SetTypeDesc(NPg::TypeDescFromPgTypeName("pgfloat4")));
+            auto alterQuery = TStringBuilder() << "ALTER TABLESTORE `" << testTableStore.GetName() << "` ADD COLUMN new_column pgfloat4;";
+
+            auto alterResult = testHelper.GetSession().ExecuteSchemeQuery(alterQuery).GetValueSync();
+            UNIT_ASSERT_VALUES_EQUAL_C(alterResult.GetStatus(), EStatus::SUCCESS, alterResult.GetIssues().ToString());
+        }
+
+        {
+            auto settings = TDescribeTableSettings().WithTableStatistics(true);
+            auto describeResult = testHelper.GetSession().DescribeTable("/Root/TableStoreTest/ColumnTableTest", settings).GetValueSync();
+            UNIT_ASSERT_C(describeResult.IsSuccess(), describeResult.GetIssues().ToString());
+
+            const auto& description = describeResult.GetTableDescription();
+            auto columns = description.GetTableColumns();
+            UNIT_ASSERT_VALUES_EQUAL(columns.size(), 4);
+        }
+
+        testHelper.ReadData("SELECT * FROM `/Root/TableStoreTest/ColumnTableTest` WHERE id=1", "[[1;#;#;[\"test_res_1\"]]]");
+        testHelper.ReadData("SELECT new_column FROM `/Root/TableStoreTest/ColumnTableTest` WHERE id=1", "[[#]]");
+        testHelper.ReadData("SELECT resource_id FROM `/Root/TableStoreTest/ColumnTableTest` WHERE id=1", "[[[\"test_res_1\"]]]");
+
+        {
+            TTestHelper::TUpdatesBuilder tableInserter(testTable.GetArrowSchema(schema));
+            tableInserter.AddRow().Add(3).Add("test_res_3").Add(-321).Add(-3.14f);
+            testHelper.BulkUpsert(testTable, tableInserter);
+        }
+
+        testHelper.ReadData("SELECT * FROM `/Root/TableStoreTest/ColumnTableTest` WHERE id=3", "[[3;\"-321\";\"-3.14\";[\"test_res_3\"]]]");
+        testHelper.ReadData("SELECT new_column FROM `/Root/TableStoreTest/ColumnTableTest` WHERE id=3", "[[\"-3.14\"]]");
+        testHelper.ReadData("SELECT resource_id FROM `/Root/TableStoreTest/ColumnTableTest` WHERE id=3", "[[[\"test_res_3\"]]]");
+        testHelper.ReadData("SELECT new_column FROM `/Root/TableStoreTest/ColumnTableTest`", "[[#];[#];[\"-3.14\"]]");
+
+        testHelper.RebootTablets(testTable.GetName());
+        testHelper.ReadData("SELECT new_column FROM `/Root/TableStoreTest/ColumnTableTest`", "[[#];[#];[\"-3.14\"]]");
+    }
+
     Y_UNIT_TEST(AddColumnErrors) {
         TKikimrSettings runnerSettings;
         runnerSettings.WithSampleTables = false;
diff --git a/ydb/core/kqp/ut/scheme/ya.make b/ydb/core/kqp/ut/scheme/ya.make
index 4b73a38eb2e..4cd03e32b9d 100644
--- a/ydb/core/kqp/ut/scheme/ya.make
+++ b/ydb/core/kqp/ut/scheme/ya.make
@@ -22,8 +22,9 @@ PEERDIR(
     library/cpp/threading/local_executor
     ydb/core/kqp
     ydb/core/kqp/ut/common
-    ydb/library/yql/sql/pg_dummy
     ydb/core/tx/columnshard/hooks/testing
+    ydb/library/yql/sql/pg
+    ydb/library/yql/parser/pg_wrapper
 )
 
 YQL_LAST_ABI_VERSION()
diff --git a/ydb/core/tx/schemeshard/olap/columns/schema.cpp b/ydb/core/tx/schemeshard/olap/columns/schema.cpp
index 511fc4736af..959ae5de426 100644
--- a/ydb/core/tx/schemeshard/olap/columns/schema.cpp
+++ b/ydb/core/tx/schemeshard/olap/columns/schema.cpp
@@ -172,13 +172,22 @@ bool TOlapColumnsDescription::Validate(const NKikimrSchemeOp::TColumnTableSchema
             return false;
         }
 
-        auto typeName = NMiniKQL::AdaptLegacyYqlType(colProto.GetType());
-        const NScheme::IType* type = typeRegistry->GetType(typeName);
-        if (!type || !TOlapColumnAdd::IsAllowedType(type->GetTypeId())) {
-            errors.AddError("Type '" + colProto.GetType() + "' specified for column '" + colName + "' is not supported");
-            return false;
+        NScheme::TTypeInfo typeInfo;
+        if (const auto& typeName = NMiniKQL::AdaptLegacyYqlType(colProto.GetType()); typeName.StartsWith("pg")) {
+            const auto typeDesc = NPg::TypeDescFromPgTypeName(typeName);
+            if (!(typeDesc && TOlapColumnAdd::IsAllowedPgType(NPg::PgTypeIdFromTypeDesc(typeDesc)))) {
+                errors.AddError("Type '" + colProto.GetType() + "' specified for column '" + colName + "' is not supported");
+                return false;
+            }
+            typeInfo = NScheme::TTypeInfo(NScheme::NTypeIds::Pg, typeDesc);
+        } else {
+            const NScheme::IType* type = typeRegistry->GetType(typeName);
+            if (!type || !TOlapColumnAdd::IsAllowedType(type->GetTypeId())) {
+                errors.AddError("Type '" + colProto.GetType() + "' specified for column '" + colName + "' is not supported");
+                return false;
+            }
+            typeInfo = NScheme::TTypeInfo(type->GetTypeId());
         }
-        NScheme::TTypeInfo typeInfo(type->GetTypeId());
 
         if (typeInfo != col->GetType()) {
             errors.AddError("Type '" + TypeName(typeInfo) + "' specified for column '" + colName + "' does not match schema preset type '" + TypeName(col->GetType()) + "'");
diff --git a/ydb/core/tx/schemeshard/olap/columns/update.cpp b/ydb/core/tx/schemeshard/olap/columns/update.cpp
index 03e26fecbce..dc0d2009a25 100644
--- a/ydb/core/tx/schemeshard/olap/columns/update.cpp
+++ b/ydb/core/tx/schemeshard/olap/columns/update.cpp
@@ -4,6 +4,10 @@
 #include <ydb/core/scheme_types/scheme_type_registry.h>
 #include <ydb/core/formats/arrow/serializer/abstract.h>
 
+extern "C" {
+#include <ydb/library/yql/parser/pg_wrapper/postgresql/src/include/catalog/pg_type_d.h>
+}
+
 namespace NKikimr::NSchemeShard {
 
     bool TOlapColumnAdd::ParseFromRequest(const NKikimrSchemeOp::TOlapColumnDescription& columnSchema, IErrorCollector& errors) {
@@ -42,21 +46,29 @@ namespace NKikimr::NSchemeShard {
             return false;
         }
 
-        auto typeName = NMiniKQL::AdaptLegacyYqlType(TypeName);
-        Y_ABORT_UNLESS(AppData()->TypeRegistry);
-        const NScheme::IType* type = AppData()->TypeRegistry->GetType(typeName);
-        if (!type) {
-            errors.AddError(TStringBuilder() << "Type '" << typeName << "' specified for column '" << Name << "' is not supported");
-            return false;
-        }
-        if (!NScheme::NTypeIds::IsYqlType(type->GetTypeId())) {
-            errors.AddError(TStringBuilder() << "Type '" << typeName << "' specified for column '" << Name << "' is not supported");
-            return false;;
-        }
-        Type = NScheme::TTypeInfo(type->GetTypeId());
-        if (!IsAllowedType(type->GetTypeId())){
-            errors.AddError(TStringBuilder() << "Type '" << typeName << "' specified for column '" << Name << "' is not supported");
-            return false;
+        if (const auto& typeName = NMiniKQL::AdaptLegacyYqlType(TypeName); typeName.StartsWith("pg")) {
+            const auto typeDesc = NPg::TypeDescFromPgTypeName(typeName);
+            if (!(typeDesc && TOlapColumnAdd::IsAllowedPgType(NPg::PgTypeIdFromTypeDesc(typeDesc)))) {
+                errors.AddError(TStringBuilder() << "Type '" << typeName << "' specified for column '" << Name << "' is not supported");
+                return false;
+            }
+            Type = NScheme::TTypeInfo(NScheme::NTypeIds::Pg, typeDesc);
+        } else {
+            Y_ABORT_UNLESS(AppData()->TypeRegistry);
+            const NScheme::IType* type = AppData()->TypeRegistry->GetType(typeName);
+            if (!type) {
+                errors.AddError(TStringBuilder() << "Type '" << typeName << "' specified for column '" << Name << "' is not supported");
+                return false;
+            }
+            if (!NScheme::NTypeIds::IsYqlType(type->GetTypeId())) {
+                errors.AddError(TStringBuilder() << "Type '" << typeName << "' specified for column '" << Name << "' is not supported");
+                return false;;
+            }
+            Type = NScheme::TTypeInfo(type->GetTypeId());
+            if (!IsAllowedType(type->GetTypeId())){
+                errors.AddError(TStringBuilder() << "Type '" << typeName << "' specified for column '" << Name << "' is not supported");
+                return false;
+            }
         }
         return true;
     }
@@ -146,6 +158,20 @@ namespace NKikimr::NSchemeShard {
         return true;
     }
 
+    bool TOlapColumnAdd::IsAllowedPgType(ui32 pgTypeId) {
+        switch (pgTypeId) {
+            case INT2OID:
+            case INT4OID:
+            case INT8OID:
+            case FLOAT4OID:
+            case FLOAT8OID:
+                return true;
+            default:
+                break;
+        }
+        return false;
+    }
+
     bool TOlapColumnAdd::IsAllowedFirstPkType(ui32 typeId) {
         switch (typeId) {
             case NYql::NProto::Uint8: // Byte
diff --git a/ydb/core/tx/schemeshard/olap/columns/update.h b/ydb/core/tx/schemeshard/olap/columns/update.h
index a9a15823dca..7bd590b6049 100644
--- a/ydb/core/tx/schemeshard/olap/columns/update.h
+++ b/ydb/core/tx/schemeshard/olap/columns/update.h
@@ -63,6 +63,7 @@ public:
     }
     static bool IsAllowedType(ui32 typeId);
     static bool IsAllowedFirstPkType(ui32 typeId);
+    static bool IsAllowedPgType(ui32 pgTypeId);
 };
 
 class TOlapColumnsUpdate {