Функции для работы с типами данных

$itemType = TypeOf($item);
SELECT CAST($foo AS ListType($itemType));  -- каст $foo к типу List<$itemType>

FormatType(Type)->String
FormatType(TypeHandle)->String

FormatTypeDiff(Type, Type)->String
FormatTypeDiff(TypeHandle, TypeHandle)->String

FormatTypeDiffPretty(Type, Type)->String
FormatTypeDiffPretty(TypeHandle, TypeHandle)->String

ParseType(String)->Type

SELECT FormatType(ParseType("List<Int32>"));  -- List<int32>

TypeOf(<any expression>)->Type

SELECT FormatType(TypeOf("foo"));  -- String

SELECT FormatType(TypeOf(AsTuple(1, 1u))); -- Tuple<Int32,Uint32>

InstanceOf(Type)->объект типа Type

SELECT InstanceOf(ParseType("Int32")) + 1.0; -- ошибка (Can't execute InstanceOf): результат зависит от (неопределенного) значения InstanceOf
SELECT FormatType(TypeOf(
    InstanceOf(ParseType("Int32")) +
    InstanceOf(ParseType("Double"))
)); -- вернет Double, так как сложение Int32 и Double возвращает Double (InstanceOf используется в контексте, где важен только его тип, но не значение)

DataType(String, [String, ...])->Type

SELECT FormatType(DataType("Bool")); -- Bool
SELECT FormatType(DataType("Decimal","5","1")); -- Decimal(5,1)

OptionalType(Type)->опциональный Type

SELECT FormatType(OptionalType(DataType("Bool"))); -- Bool?
SELECT FormatType(OptionalType(ParseType("List<String?>"))); -- List<String?>?

ListType(Type)->тип списка с элементами типа Type
StreamType(Type)->тип потока с элементами типа Type

SELECT FormatType(ListType(DataType("Bool"))); -- List<Bool>

DictType(Type, Type)->тип словаря

SELECT FormatType(DictType(
    DataType("String"),
    DataType("Double")
)); -- Dict<String,Double>

TupleType(Type, ...)->тип кортежа

SELECT FormatType(TupleType(
    DataType("String"),
    DataType("Double"),
    OptionalType(DataType("Bool"))
)); -- Tuple<String,Double,Bool?>

StructType(Type AS ElementName1, Type AS ElementName2, ...)->тип структуры

SELECT FormatType(StructType(
    DataType("Bool") AS MyBool,
    ListType(DataType("String")) AS StringList
)); -- Struct<'MyBool':Bool,'StringList':List<String>>

VariantType(StructType)->тип варианта над структурой
VariantType(TupleType)->тип варианта над кортежем

SELECT FormatType(VariantType(
  ParseType("Struct<foo:Int32,bar:Double>")
)); -- Variant<'bar':Double,'foo':Int32>

ResourceType(String)->тип ресурса

SELECT FormatType(ResourceType("Foo")); -- Resource<'Foo'>

CallableType(Uint32, Type, [Type, ...])->тип вызываемого значения

SELECT FormatType(CallableType(
  1, -- optional args count
  DataType("Double"), -- result type
  DataType("String"), -- arg #1 type
  OptionalType(DataType("Int64")) -- arg #2 type
)); -- Callable<(String,[Int64?])->Double>

GenericType()->тип
UnitType()->тип
VoidType()->тип

SELECT FormatType(VoidType()); -- Void

OptionalItemType(OptionalType)->тип элемента опционального типа
ListItemType(ListType)->тип элемента списочного типа
StreamItemType(StreamType)->тип элемента потокового типа

SELECT FormatType(ListItemType(
  ParseType("List<Int32>")
)); -- Int32

SELECT FormatType(ListItemType(
  ParseTypeHandle("List<Int32>")
)); -- Int32

DictKetType(DictType)->тип ключа словаря
DictPayloadType(DictType)->тип значения словаря

SELECT FormatType(DictKeyType(
  ParseType("Dict<Int32,String>")
)); -- Int32

TupleElementType(TupleType, String)->тип элемента кортежа

SELECT FormatType(TupleElementType(
  ParseType("Tuple<Int32,Double>"), "1"
)); -- Double

StructMemberType(StructType, String)->тип элемента структуры

SELECT FormatType(StructMemberType(
  ParseType("Struct<foo:Int32,bar:Double>"), "foo"
)); -- Int32

CallableResultType(CallableType)->тип результата вызываемого значения
CallableArgumentType(CallableType, Uint32)->тип аругмента вызываемого значения

$callable_type = ParseType("(String,Bool)->Double");

SELECT FormatType(CallableResultType(
    $callable_type
)), -- Double
FormatType(CallableArgumentType(
    $callable_type, 1
)); -- Bool

VariantUnderlyingType(VariantType)->низлежащий тип варианта

SELECT FormatType(VariantUnderlyingType(
  ParseType("Variant<foo:Int32,bar:Double>")
)), -- Struct<'bar':Double,'foo':Int32>
FormatType(VariantUnderlyingType(
  ParseType("Variant<Int32,Double>")
)); -- Tuple<Int32,Double>

SELECT FormatType(VariantUnderlyingType(
  ParseTypeHandle("Variant<foo:Int32,bar:Double>")
)), -- Struct<'bar':Double,'foo':Int32>
FormatType(VariantUnderlyingType(
  ParseTypeHandle("Variant<Int32,Double>")
)); -- Tuple<Int32,Double>

TypeHandle(Type)->хэндл типа

SELECT FormatType(TypeHandle(TypeOf("foo")));  -- String

EvaluateType(TypeHandle)->тип

SELECT FormatType(EvaluateType(TypeHandle(TypeOf("foo"))));  -- String

ParseTypeHandle(String)->хэндл типа

SELECT FormatType(ParseTypeHandle("List<Int32>"));  -- List<int32>

TypeKind(TypeHandle)->String

SELECT TypeKind(TypeHandle(TypeOf("foo")));  -- Data
SELECT TypeKind(ParseTypeHandle("List<Int32>"));  -- List

DataTypeComponents(DataTypeHandle)->List<String>

SELECT DataTypeComponents(TypeHandle(TypeOf("foo")));  -- ["String"]
SELECT DataTypeComponents(ParseTypeHandle("Decimal(4,1)"));  -- ["Decimal", "4", "1"]

DataTypeHandle(List<String>)->хэндл примитивного типа данных

SELECT FormatType(DataTypeHandle(
    AsList("String")
)); -- String

SELECT FormatType(DataTypeHandle(
    AsList("Decimal", "4", "1")
)); -- Decimal(4,1)

OptionalTypeHandle(TypeHandle)->хэндл опционального типа

SELECT FormatType(OptionalTypeHandle(
    TypeHandle(DataType("Bool"))
)); -- Bool?

PgTypeName(PgTypeHandle)->String

SELECT PgTypeName(ParseTypeHandle("pgint4")); -- int4

PgTypeHandle(String)->хендл типа

SELECT FormatType(PgTypeHandle("int4")); -- pgint4

ListTypeHandle(TypeHandle)->хэндл списочного типа
StreamTypeHandle(TypeHandle)->хэндл потокового типа

SELECT FormatType(ListTypeHandle(
    TypeHandle(DataType("Bool"))
)); -- List<Bool>

EmptyListTypeHandle()->хэндл типа пустого списка
EmptyDictTypeHandle()->хэндл типа пустого словаря

SELECT FormatType(EmptyListTypeHandle()); -- EmptyList

TupleTypeComponents(TupleTypeHandle)->List<TypeHandle>

SELECT ListMap(
   TupleTypeComponents(
       ParseTypeHandle("Tuple<Int32, String>")
   ),
   ($x)->{
       return FormatType($x)
   }
); -- ["Int32", "String"]

TupleTypeHandle(List<TypeHandle>)->хэндл типа кортежа

SELECT FormatType(
    TupleTypeHandle(
        AsList(
            ParseTypeHandle("Int32"),
            ParseTypeHandle("String")
        )
    )
); -- Tuple<Int32,String>

StructTypeComponents(StructTypeHandle)->List<Struct<Name:String, Type:TypeHandle>>

SELECT ListMap(
    StructTypeComponents(
        ParseTypeHandle("Struct<a:Int32, b:String>")
    ),
    ($x) -> {
        return AsTuple(
            FormatType($x.Type),
            $x.Name
        )
    }
); -- [("Int32","a"), ("String","b")]

StructTypeHandle(List<Struct<Name:String, Type:TypeHandle>>)->хэндл типа структуры

SELECT FormatType(
    StructTypeHandle(
        AsList(
            AsStruct(ParseTypeHandle("Int32") as Type,"a" as Name),
            AsStruct(ParseTypeHandle("String") as Type, "b" as Name)
        )
    )
); -- Struct<'a':Int32,'b':String>

DictTypeComponents(DictTypeHandle)->Struct<Key:TypeHandle, Payload:TypeHandle>

$d = DictTypeComponents(ParseTypeHandle("Dict<Int32,String>"));

SELECT
    FormatType($d.Key),     -- Int32
    FormatType($d.Payload); -- String

DictTypeHandle(TypeHandle, TypeHandle)->хэндл типа словаря

SELECT FormatType(
    DictTypeHandle(
        ParseTypeHandle("Int32"),
        ParseTypeHandle("String")
    )
); -- Dict<Int32, String>

ResourceTypeTag(ResourceTypeHandle)->String

SELECT ResourceTypeTag(ParseTypeHandle("Resource<foo>")); -- foo

ResourceTypeHandle(String)->хэндл типа ресурса

SELECT FormatType(ResourceTypeHandle("foo")); -- Resource<'foo'>

TaggedTypeComponents(TaggedTypeHandle)->Struct<Base:TypeHandle, Tag:String>

$t = TaggedTypeComponents(ParseTypeHandle("Tagged<Int32,foo>"));

SELECT FormatType($t.Base), $t.Tag; -- Int32, foo

TaggedTypeHandle(TypeHandle, String)->хэндл декорированного типа

SELECT FormatType(TaggedTypeHandle(
    ParseTypeHandle("Int32"), "foo"
)); -- Tagged<Int32, 'foo'>

VariantTypeHandle(StructTypeHandle)->хэндл типа варианта над структурой
VariantTypeHandle(TupleTypeHandle)->хэндл типа варианта над кортежем

SELECT FormatType(VariantTypeHandle(
    ParseTypeHandle("Tuple<Int32, String>")
)); -- Variant<Int32, String>

VoidTypeHandle()->хэндл типа Void
NullTypeHandle()->хэндл типа Null

SELECT FormatType(VoidTypeHandle()); -- Void
SELECT FormatType(NullTypeHandle()); -- Null

CallableTypeComponents(CallableTypeHandle)->
Struct<
    Arguments:List<Struct<
        Flags:List<String>,
        Name:String,
        Type:TypeHandle>>,
    OptionalArgumentsCount:Uint32,
    Payload:String,
    Result:TypeHandle
>

$formatArgument = ($x) -> {
    return AsStruct(
        FormatType($x.Type) as Type,
        $x.Name as Name,
        $x.Flags as Flags
    )
};

$formatCallable = ($x) -> {
    return AsStruct(
        $x.OptionalArgumentsCount as OptionalArgumentsCount,
        $x.Payload as Payload,
        FormatType($x.Result) as Result,
        ListMap($x.Arguments, $formatArgument) as Arguments
    )
};

SELECT $formatCallable(
    CallableTypeComponents(
        ParseTypeHandle("(Int32,[bar:Double?{Flags:AutoMap}])->String")
    )
);  -- (OptionalArgumentsCount: 1, Payload: "", Result: "String", Arguments: [
    --   (Type: "Int32", Name: "", Flags: []),
    --   (Type: "Double?", Name: "bar", Flags: ["AutoMap"]),
    -- ])

CallableArgument(TypeHandle, [String, [List<String>]])->Struct<Flags:List<String>,Name:String,Type:TypeHandle>

CallableTypeHandle(TypeHandle, List<Struct<Flags:List<String>,Name:String,Type:TypeHandle>>, [Uint32, [String]])->хэндл типа вызываемого значения

SELECT FormatType(
    CallableTypeHandle(
        ParseTypeHandle("String"),
        AsList(
            CallableArgument(ParseTypeHandle("Int32")),
            CallableArgument(ParseTypeHandle("Double?"), "bar", AsList("AutoMap"))
        ),
        1
    )
);  -- Callable<(Int32,['bar':Double?{Flags:AutoMap}])->String>

LambdaArgumentsCount(LambdaFunction)->Uint32

SELECT LambdaArgumentsCount(($x, $y)->($x+$y))
; -- 2

LambdaOptionalArgumentsCount(LambdaFunction)->Uint32

SELECT LambdaOptionalArgumentsCount(($x, $y, $z?)->(if($x,$y,$z)))
; -- 1