Merge be656f4 into f5de617

Author: MrLolthe1st

ydb/library/yql/parser/pg_catalog/catalog.cpp

@@ -28,6 +28,10 @@ using TCasts = THashMap<ui32, TCastDesc>;
 
 using TAggregations = THashMap<ui32, TAggregateDesc>;
 
+using TAms = THashMap<ui32, TAmDesc>;
+
+using TNamespaces = THashMap<decltype(TNamespaceDesc::Oid), TNamespaceDesc>;
+
 // We parse OpFamilies' IDs for now. If we ever needed oid_symbol,
 // create TOpFamilyDesc class alike other catalogs
 using TOpFamilies = THashMap<TString, ui32>;
@@ -274,6 +278,8 @@ class TOperatorsParser : public TParser {
             LastOperator.OperId = FromString<ui32>(value);
         } else if (key == "oprname") {
             LastOperator.Name = value;
+        } else if (key == "descr") {
+            LastOperator.Descr = value;
         } else if (key == "oprkind") {
             if (value == "r") {
                 LastOperator.Kind = EOperKind::RightUnary;
@@ -355,6 +361,8 @@ class TProcsParser : public TParser {
             LastProc.ProcId = FromString<ui32>(value);
         } else if (key == "provariadic") {
             IsSupported = false;
+        } else if (key == "descr") {
+            LastProc.Descr = value;
         } else if (key == "prokind") {
             if (value == "f") {
                 LastProc.Kind = EProcKind::Function;
@@ -493,6 +501,8 @@ class TTypesParser : public TParser {
             LastType.TypeId = FromString<ui32>(value);
         } else if (key == "array_type_oid") {
             LastType.ArrayTypeId = FromString<ui32>(value);
+        } else if (key == "descr") {
+            LastType.Descr = value;
         } else if (key == "typname") {
             LastType.Name = value;
         } else if (key == "typcategory") {
@@ -1084,6 +1094,40 @@ class TAmOpsParser : public TParser {
     bool IsSupported = true;
 };
 
+
+class TAmsParser : public TParser {
+public:
+    TAmsParser(TAms& ams) : Ams_(ams) {}
+
+    void OnKey(const TString& key, const TString& value) override {
+        if (key == "oid") {
+            CurrDesc_.Oid = FromString<ui32>(value);
+        } else if (key == "descr") {
+            CurrDesc_.Descr = value;
+        } else if (key == "amname") {
+            CurrDesc_.AmName = value;
+        } else if (key == "amtype") {
+            Y_ENSURE(value.Size() == 1);
+            if ((char)EAmType::Index == value[0]) {
+                CurrDesc_.AmType = EAmType::Index;
+            } else if ((char)EAmType::Table == value[0]) {
+                CurrDesc_.AmType = EAmType::Table;
+            } else {
+                Y_ENSURE(false, "Expected correct AmType");
+            }
+        }
+    }
+
+    void OnFinish() override {
+        Ams_[CurrDesc_.Oid] = std::move(CurrDesc_);
+        CurrDesc_ = TAmDesc();
+    }
+
+private:
+    TAmDesc CurrDesc_;
+    TAms& Ams_;
+};
+
 class TAmProcsParser : public TParser {
 public:
     TAmProcsParser(TAmProcs& amProcs, const THashMap<TString, ui32>& typeByName,
@@ -1169,6 +1213,8 @@ class TConversionsParser : public TParser {
         } else if (key == "conforencoding") {
             Y_ENSURE(value.StartsWith("PG_"));
             LastConversion.From = value.substr(3);
+        } else if (key == "descr") {
+            LastConversion.Descr = value;
         } else if (key == "contoencoding") {
             Y_ENSURE(value.StartsWith("PG_"));
             LastConversion.To = value.substr(3);
@@ -1274,6 +1320,24 @@ TConversions ParseConversions(const TString& dat, const THashMap<TString, TVecto
     return ret;
 }
 
+TAms ParseAms(const TString& dat) {
+    TAms ret;
+    TAmsParser parser(ret);
+    parser.Do(dat);
+    return ret;
+}
+
+TNamespaces FillNamespaces() {
+    const ui32 PgInformationSchemaNamepace = 1;
+    const ui32 PgCatalogNamepace = 11;
+    const ui32 PgPublicNamepace = 2200;
+    return TNamespaces{
+        {PgInformationSchemaNamepace, TNamespaceDesc{PgInformationSchemaNamepace, "information_schema", "information_schema namespace"}},
+        {PgPublicNamepace, TNamespaceDesc{PgPublicNamepace, "public", "public namespace"}},
+        {PgCatalogNamepace, TNamespaceDesc{PgCatalogNamepace, "pg_catalog", "pg_catalog namespace"}},
+    };
+}
+
 struct TCatalog {
     TCatalog()
         : ProhibitedProcs({
@@ -1358,6 +1422,8 @@ struct TCatalog {
         Y_ENSURE(NResource::FindExact("pg_amop.dat", &amOpData));
         TString conversionData;
         Y_ENSURE(NResource::FindExact("pg_conversion.dat", &conversionData));
+        TString amData;
+        Y_ENSURE(NResource::FindExact("pg_am.dat", &amData));
         THashMap<ui32, TLazyTypeInfo> lazyTypeInfos;
         Types = ParseTypes(typeData, lazyTypeInfos);
         for (const auto& [k, v] : Types) {
@@ -1480,6 +1546,8 @@ struct TCatalog {
         OpClasses = ParseOpClasses(opClassData, TypeByName, opFamilies);
         AmOps = ParseAmOps(amOpData, TypeByName, Types, OperatorsByName, Operators, opFamilies);
         AmProcs = ParseAmProcs(amProcData, TypeByName, ProcByName, Procs, opFamilies);
+        Ams = ParseAms(amData);
+        Namespaces = FillNamespaces();
         for (auto& [k, v] : Types) {
             if (v.TypeId != v.ArrayTypeId) {
                 auto lookupId = (v.TypeId == VarcharOid ? TextOid : v.TypeId);
@@ -1522,6 +1590,8 @@ struct TCatalog {
     TTypes Types;
     TCasts Casts;
     TAggregations Aggregations;
+    TAms Ams;
+    TNamespaces Namespaces;
     TOpClasses OpClasses;
     TAmOps AmOps;
     TAmProcs AmProcs;
@@ -1662,6 +1732,55 @@ void EnumTypes(std::function<void(ui32, const TTypeDesc&)> f) {
     }
 }
 
+const TAmDesc& LookupAm(ui32 oid) {
+    const auto& catalog = TCatalog::Instance();
+    const auto typePtr = catalog.Ams.FindPtr(oid);
+    if (!typePtr) {
+        throw yexception() << "No such am: " << oid;
+    }
+
+    return *typePtr;
+}
+
+void EnumAm(std::function<void(ui32, const TAmDesc&)> f) {
+    const auto& catalog = TCatalog::Instance();
+    for (const auto& [oid, desc] : catalog.Ams) {
+        f(oid, desc);
+    }
+}
+
+void EnumConversions(std::function<void(const TConversionDesc&)> f) {
+    const auto& catalog = TCatalog::Instance();
+    for (const auto& [_, desc] : catalog.Conversions) {
+        f(desc);
+    }
+}
+
+const TNamespaceDesc& LookupNamespace(ui32 oid) {
+    const auto& catalog = TCatalog::Instance();
+    const auto typePtr = catalog.Namespaces.FindPtr(oid);
+    if (!typePtr) {
+        throw yexception() << "No such namespace: " << oid;
+    }
+
+    return *typePtr;
+}
+
+void EnumNamespace(std::function<void(ui32, const TNamespaceDesc&)> f) {
+    const auto& catalog = TCatalog::Instance();
+    for (const auto& [oid, desc] : catalog.Namespaces) {
+        f(oid, desc);
+    }
+}
+
+void EnumOperators(std::function<void(const TOperDesc&)> f) {
+    const auto& catalog = TCatalog::Instance();
+    for (const auto& [_, desc] : catalog.Operators) {
+        f(desc);
+    }
+}
+
+
 bool HasCast(ui32 sourceId, ui32 targetId) {
     const auto& catalog = TCatalog::Instance();
     return catalog.CastsByDir.contains(std::make_pair(sourceId, targetId));

ydb/library/yql/parser/pg_catalog/catalog.h

@@ -33,6 +33,7 @@ enum class EOperKind {
 struct TOperDesc {
     ui32 OperId = 0;
     TString Name;
+    TString Descr;
     EOperKind Kind = EOperKind::Binary;
     ui32 LeftType = 0;
     ui32 RightType = 0;
@@ -50,6 +51,7 @@ struct TProcDesc {
     ui32 ProcId = 0;
     TString Name;
     TString Src;
+    TString Descr;
     TVector<ui32> ArgTypes;
     ui32 ResultType = 0;
     bool IsStrict = true;
@@ -81,6 +83,7 @@ constexpr char InvalidCategory = '\0';
 struct TTypeDesc {
     ui32 TypeId = 0;
     ui32 ArrayTypeId = 0;
+    TString Descr;
     TString Name;
     ui32 ElementTypeId = 0;
     bool PassByValue = false;
@@ -155,6 +158,24 @@ struct TAggregateDesc {
     TString InitValue;
 };
 
+enum class EAmType {
+    Table = 't',
+    Index = 'i'
+};
+
+struct TAmDesc {
+    ui32 Oid = 0;
+    TString Descr;
+    TString AmName;
+    EAmType AmType = EAmType::Index;
+};
+
+struct TNamespaceDesc {
+    ui32 Oid = 0;
+    TString Name;
+    TString Descr;
+};
+
 enum class EOpClassMethod {
     Btree,
     Hash
@@ -206,6 +227,7 @@ struct TConversionDesc {
     ui32 ConversionId = 0;
     TString From;
     TString To;
+    TString Descr;
     ui32 ProcId = 0;
 };
 
@@ -223,6 +245,16 @@ TMaybe<TIssue> LookupCommonType(const TVector<ui32>& typeIds, const std::functio
 TMaybe<TIssue> LookupCommonType(const TVector<ui32>& typeIds, const std::function<TPosition(size_t i)>& GetPosition, const TTypeDesc*& typeDesc, bool& castsNeeded);
 void EnumTypes(std::function<void(ui32, const TTypeDesc&)> f);
 
+const TAmDesc& LookupAm(ui32 oid);
+void EnumAm(std::function<void(ui32, const TAmDesc&)> f);
+
+void EnumConversions(std::function<void(const TConversionDesc&)> f);
+
+const TNamespaceDesc& LookupNamespace(ui32 oid);
+void EnumNamespace(std::function<void(ui32, const TNamespaceDesc&)> f);
+
+void EnumOperators(std::function<void(const TOperDesc&)> f);
+
 bool HasCast(ui32 sourceId, ui32 targetId);
 const TCastDesc& LookupCast(ui32 sourceId, ui32 targetId);
 

ydb/library/yql/parser/pg_catalog/ya.make

@@ -9,6 +9,7 @@ RESOURCE(../pg_wrapper/postgresql/src/include/catalog/pg_opfamily.dat pg_opfamil
 RESOURCE(../pg_wrapper/postgresql/src/include/catalog/pg_opclass.dat pg_opclass.dat)
 RESOURCE(../pg_wrapper/postgresql/src/include/catalog/pg_amproc.dat pg_amproc.dat)
 RESOURCE(../pg_wrapper/postgresql/src/include/catalog/pg_amop.dat pg_amop.dat)
+RESOURCE(../pg_wrapper/postgresql/src/include/catalog/pg_am.dat pg_am.dat)
 RESOURCE(../pg_wrapper/postgresql/src/include/catalog/pg_conversion.dat pg_conversion.dat)
 
 SRCS(