PostgreSQLProtocol.h

#pragma once

#include <IO/ReadBuffer.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteHelpers.h>
#include <Interpreters/Session.h>
#include <Columns/IColumn.h>
#include <Common/Exception.h>
#include <Common/logger_useful.h>
#include <Common/Base64.h>
#include <Common/UnorderedMapWithMemoryTracking.h>
#include <Common/VectorWithMemoryTracking.h>
#include <Poco/RegularExpression.h>
#include <Poco/Net/StreamSocket.h>
#include <Parsers/ParserPreparedStatement.h>
#include <Poco/RandomStream.h>
#include <Poco/SHA1Engine.h>
#include <Access/Credentials.h>
#include <algorithm>
#include <unordered_map>
#include <utility>

#include <Interpreters/Context.h>
#include <Access/AccessControl.h>
#include <Access/User.h>
#include <fmt/core.h>

namespace DB
{

namespace ErrorCodes
{
    extern const int BAD_ARGUMENTS;
    extern const int UNKNOWN_PACKET_FROM_CLIENT;
    extern const int UNEXPECTED_PACKET_FROM_CLIENT;
    extern const int NOT_IMPLEMENTED;
    extern const int UNKNOWN_TYPE;
    extern const int LIMIT_EXCEEDED;
}


namespace PostgreSQLProtocol
{

namespace Messaging
{

enum class FrontMessageType : Int32
{
// first message types
    CANCEL_REQUEST = 80877102,
    SSL_REQUEST = 80877103,
    GSSENC_REQUEST = 80877104,

// other front message types
    PASSWORD_MESSAGE = 'p',
    QUERY = 'Q',
    TERMINATE = 'X',
    PARSE = 'P',
    BIND = 'B',
    DESCRIBE = 'D',
    SYNC = 'S',
    FLUSH = 'H',
    CLOSE = 'C',
    EXECUTE = 'E',
    COPY_DATA = 'd',
    COPY_COMPLETION = 'c',
};

enum class MessageType : Int32
{
// common
    ERROR_RESPONSE = 0,
    CANCEL_REQUEST = 1,
    COMMAND_COMPLETE = 2,
    NOTICE_RESPONSE = 3,
    NOTIFICATION_RESPONSE = 4,
    PARAMETER_STATUS = 5,
    READY_FOR_QUERY = 6,
    SYNC = 7,
    SYNC_COMPLETE = 7,
    TERMINATE = 8,

// start up and authentication
    AUTHENTICATION_OK = 30,
    AUTHENTICATION_KERBEROS_V5 = 31,
    AUTHENTICATION_CLEARTEXT_PASSWORD = 32,
    AUTHENTICATION_MD5_PASSWORD = 33,
    AUTHENTICATION_SCM_CREDENTIAL = 34,
    AUTHENTICATION_GSS = 35,
    AUTHENTICATION_SSPI = 36,
    AUTHENTICATION_GSS_CONTINUE = 37,
    AUTHENTICATION_SASL = 38,
    AUTHENTICATION_SASL_CONTINUE = 39,
    AUTHENTICATION_SASL_FINAL = 40,
    BACKEND_KEY_DATA = 41,
    GSSENC_REQUEST = 42,
    GSS_RESPONSE = 43,
    NEGOTIATE_PROTOCOL_VERSION = 44,
    PASSWORD_MESSAGE = 45,
    SASL_INITIAL_RESPONSE = 46,
    SASL_RESPONSE = 47,
    SSL_REQUEST = 48,
    STARTUP_MESSAGE = 49,

// simple query
    DATA_ROW = 100,
    EMPTY_QUERY_RESPONSE = 101,
    ROW_DESCRIPTION = 102,
    QUERY = 103,

// extended query
    BIND = 120,
    BIND_COMPLETE = 121,
    CLOSE = 122,
    CLOSE_COMPLETE = 123,
    DESCRIBE = 124,
    EXECUTE = 125,
    FLUSH = 126,
    NODATA = 127,
    PARAMETER_DESCRIPTION = 128,
    PARSE = 129,
    PARSE_COMPLETE = 130,
    PORTAL_SUSPENDED = 131,

// copy query
    COPY_DATA = 171,
    COPY_DONE = 172,
    COPY_FAIL = 173,
    COPY_IN_RESPONSE = 174,
    COPY_OUT_RESPONSE = 175,
    COPY_BOTH_RESPONSE = 176,

// function query (deprecated by the protocol)
    FUNCTION_CALL = 190,
    FUNCTION_CALL_RESPONSE = 191,
};

/** Column 'typelem' from 'pg_type' table. NB: not all types are compatible with PostgreSQL's ones */
enum class ColumnType : Int32
{
    BOOL = 16,
    CHAR = 18,
    INT8 = 20,
    INT2 = 21,
    INT4 = 23,
    FLOAT4 = 700,
    FLOAT8 = 701,
    VARCHAR = 1043,
    DATE = 1082,
    NUMERIC = 1700,
    UUID = 2950,
};

class ColumnTypeSpec
{
public:
    ColumnType type;
    Int16 len;

    ColumnTypeSpec(ColumnType type_, Int16 len_) : type(type_), len(len_) {}
};

ColumnTypeSpec convertDataTypeToPostgresColumnTypeSpec(const DataTypePtr & data_type);

class MessageTransport
{
private:
    ReadBuffer * in;
    WriteBuffer * out;

public:
    explicit MessageTransport(WriteBuffer * out_) : in(nullptr), out(out_) {}

    MessageTransport(ReadBuffer * in_, WriteBuffer * out_): in(in_), out(out_) {}

    template<typename TMessage>
    std::unique_ptr<TMessage> receiveWithPayloadSize(Int32 payload_size)
    {
        std::unique_ptr<TMessage> message = std::make_unique<TMessage>(payload_size);
        message->deserialize(*in);
        return message;
    }

    template<typename TMessage>
    std::unique_ptr<TMessage> receive()
    {
        std::unique_ptr<TMessage> message = std::make_unique<TMessage>();
        message->deserialize(*in);
        return message;
    }

    FrontMessageType receiveMessageType()
    {
        char type = 0;
        in->readStrict(type);
        return static_cast<FrontMessageType>(type);
    }

    template<typename TMessage>
    void send(TMessage & message, bool flush=false)
    {
        message.serialize(*out);
        if (flush)
            out->next();
    }

    template<typename TMessage>
    void send(TMessage && message, bool flush=false)
    {
        send(message, flush);
    }

    void send(char message, bool flush=false)
    {
        out->write(message);
        if (flush)
            out->next();
    }

    void dropMessage()
    {
        Int32 size = 0;
        readBinaryBigEndian(size, *in);
        if (size < 4)
            throw Exception(ErrorCodes::UNKNOWN_PACKET_FROM_CLIENT,
                            "Wrong message length {} received from client, it must be at least 4", size);
        in->ignore(size - 4);
    }

    void flush()
    {
        out->next();
    }
};

/** Basic class for messages sent by client or server. */
class IMessage
{
public:
    virtual MessageType getMessageType() const = 0;

    virtual ~IMessage() = default;
};

class ISerializable
{
public:
    /** Should be overridden for sending the message */
    virtual void serialize(WriteBuffer & out) const = 0;

    /** Size of the message in bytes including message length part (4 bytes) */
    virtual Int32 size() const = 0;

    ISerializable() = default;

    ISerializable(const ISerializable &) = default;

    virtual ~ISerializable() = default;
};

class FrontMessage : public IMessage
{
public:
    /** Should be overridden for receiving the message
     * NB: This method should not read the first byte, which means the type of the message
     * (if type is provided for the message by the protocol).
     */
    virtual void deserialize(ReadBuffer & in) = 0;
};

class BackendMessage : public IMessage, public ISerializable
{};

class FirstMessage : public FrontMessage
{
public:
    Int32 payload_size;

    FirstMessage() = delete;
    explicit FirstMessage(int payload_size_) : payload_size(payload_size_) {}
};

class CancelRequest : public FirstMessage
{
public:
    Int32 process_id = 0;
    Int32 secret_key = 0;

    explicit CancelRequest(int payload_size_) : FirstMessage(payload_size_) {}

    void deserialize(ReadBuffer & in) override
    {
        readBinaryBigEndian(process_id, in);
        readBinaryBigEndian(secret_key, in);
    }

    MessageType getMessageType() const override
    {
        return MessageType::CANCEL_REQUEST;
    }
};

class ErrorOrNoticeResponse : BackendMessage
{
public:
    enum Severity {ERROR = 0, FATAL = 1, PANIC = 2, WARNING = 3, NOTICE = 4, DEBUG = 5, INFO = 6, LOG = 7};

private:
    Severity severity;
    String sql_state;
    String message;

    String enum_to_string[8] = {"ERROR", "FATAL", "PANIC", "WARNING", "NOTICE", "DEBUG", "INFO", "LOG"};

    char isErrorOrNotice() const
    {
        switch (severity)
        {
            case ERROR:
            case FATAL:
            case PANIC:
                return 'E';
            case WARNING:
            case NOTICE:
            case DEBUG:
            case INFO:
            case LOG:
                return 'N';
        }
        throw Exception(ErrorCodes::UNKNOWN_TYPE, "Unknown severity type {}", std::to_string(severity));
    }

public:
    ErrorOrNoticeResponse(const Severity & severity_, const String & sql_state_, const String & message_)
    : severity(severity_)
    , sql_state(sql_state_)
    , message(message_)
    {}

    void serialize(WriteBuffer & out) const override
    {
        out.write(isErrorOrNotice());
        Int32 sz = size();
        writeBinaryBigEndian(sz, out);

        out.write('S');
        writeNullTerminatedString(enum_to_string[severity], out);
        out.write('C');
        writeNullTerminatedString(sql_state, out);
        out.write('M');
        writeNullTerminatedString(message, out);

        out.write(0);
    }

    Int32 size() const override
    {
        // message length part + (1 + sizes of other fields + 1) + null byte in the end of the message
        return static_cast<Int32>(
            4 +
            (1 + enum_to_string[severity].size() + 1) +
            (1 + sql_state.size() + 1) +
            (1 + message.size() + 1) +
            1);
    }

    MessageType getMessageType() const override
    {
        if (isErrorOrNotice() == 'E')
            return MessageType::ERROR_RESPONSE;
        return MessageType::NOTICE_RESPONSE;
    }
};

class ReadyForQuery : BackendMessage
{
public:
    void serialize(WriteBuffer &out) const override
    {
        out.write('Z');
        writeBinaryBigEndian(size(), out);
        // 'I' means that we are not in a transaction block. We use it here, because ClickHouse doesn't support transactions.
        out.write('I');
    }

    Int32 size() const override
    {
        return 4 + 1;
    }

    MessageType getMessageType() const override
    {
        return MessageType::READY_FOR_QUERY;
    }
};

class Terminate : FrontMessage
{
public:
    void deserialize(ReadBuffer & in) override
    {
        in.ignore(4);
    }

    MessageType getMessageType() const override
    {
        return MessageType::TERMINATE;
    }
};

class StartupMessage : FirstMessage
{
public:
    String user;
    String database;
    // includes username, may also include database and other runtime parameters
    UnorderedMapWithMemoryTracking<String, String> parameters;

    explicit StartupMessage(Int32 payload_size_) : FirstMessage(payload_size_) {}

    void deserialize(ReadBuffer & in) override
    {
        Int32 ps = payload_size - 1;
        while (ps > 0)
        {
            String parameter_name;
            String parameter_value;
            readNullTerminated(parameter_name, in);
            readNullTerminated(parameter_value, in);
            ps -= parameter_name.size() + 1;
            ps -= parameter_value.size() + 1;

            if (parameter_name == "user")
            {
                user = parameter_value;
            }
            else if (parameter_name == "database")
            {
                database = parameter_value;
            }

            parameters.insert({std::move(parameter_name), std::move(parameter_value)});

            if (payload_size < 0)
            {
                throw Exception(ErrorCodes::UNKNOWN_PACKET_FROM_CLIENT,
                                "Size of payload is larger than one declared in the message of type {}.",
                                static_cast<UInt64>(getMessageType()));
            }
        }
        in.ignore();
    }

    MessageType getMessageType() const override
    {
        return MessageType::STARTUP_MESSAGE;
    }
};

class AuthenticationCleartextPassword : public Messaging::BackendMessage
{
public:
    void serialize(WriteBuffer & out) const override
    {
        out.write('R');
        writeBinaryBigEndian(size(), out);
        writeBinaryBigEndian(static_cast<Int32>(3), out); // specifies that a clear-text password is required (by protocol)
    }

    Int32 size() const override
    {
        // length of message + special int32
        return 4 + 4;
    }

    MessageType getMessageType() const override
    {
        return MessageType::AUTHENTICATION_CLEARTEXT_PASSWORD;
    }
};

class AuthenticationSASL : public Messaging::BackendMessage
{
public:
    static constexpr std::string_view supported_method = "SCRAM-SHA-256";

    void serialize(WriteBuffer & out) const override
    {
        out.write('R');
        writeBinaryBigEndian(size(), out);
        writeBinaryBigEndian(static_cast<Int32>(10), out);
        writeNullTerminatedString(String(supported_method), out);
        out.write(0);
    }

    Int32 size() const override
    {
        return 4 + 4 + supported_method.size() + 1 + 1;
    }

    MessageType getMessageType() const override
    {
        return MessageType::AUTHENTICATION_SASL;
    }
};

class SASLInitialResponse : public Messaging::FrontMessage
{
public:
    String auth_method;
    String sasl_mechanism;

    void deserialize(ReadBuffer & in) override
    {
        UInt8 message_type = 0;
        readBinaryBigEndian(message_type, in);
        Int32 size = 0;
        readBinaryBigEndian(size, in);
        readNullTerminated(auth_method, in);
        Int32 size_sasl_mechanism = 0;
        readBinaryBigEndian(size_sasl_mechanism, in);
        /// -1 is the protocol sentinel for "no initial response"; any other negative value is malformed.
        if (size_sasl_mechanism < -1)
            throw Exception(ErrorCodes::UNKNOWN_PACKET_FROM_CLIENT,
                            "Wrong SASL mechanism length {} in SASLInitialResponse, it must not be less than -1", size_sasl_mechanism);
        if (size_sasl_mechanism > 0)
        {
            sasl_mechanism.resize(size_sasl_mechanism);
            in.readStrict(sasl_mechanism.data(), size_sasl_mechanism);
        }
    }

    MessageType getMessageType() const override
    {
        return MessageType::SASL_INITIAL_RESPONSE;
    }
};

class AuthenticationSASLContinue : public Messaging::BackendMessage
{
public:
    String data;

    explicit AuthenticationSASLContinue(const String & data_)
        : data(data_)
    {
    }

    void serialize(WriteBuffer & out) const override
    {
        out.write('R');
        writeBinaryBigEndian(size(), out);
        writeBinaryBigEndian(static_cast<Int32>(11), out);
        out.write(data.data(), data.size());
    }

    Int32 size() const override
    {
        return 4 + 4 + static_cast<Int32>(data.size());
    }

    MessageType getMessageType() const override
    {
        return MessageType::AUTHENTICATION_SASL_CONTINUE;
    }
};

class SASLResponse : public Messaging::FrontMessage
{
public:
    String sasl_mechanism;

    void deserialize(ReadBuffer & in) override
    {
        UInt8 message_type = 0;
        readBinaryBigEndian(message_type, in);
        Int32 size = 0;
        readBinaryBigEndian(size, in);
        if (size < 4)
            throw Exception(ErrorCodes::UNKNOWN_PACKET_FROM_CLIENT,
                            "Wrong message length {} in SASLResponse, it must be at least 4", size);
        sasl_mechanism.resize(size - 4);
        in.readStrict(sasl_mechanism.data(), size - 4);
    }

    MessageType getMessageType() const override
    {
        return MessageType::SASL_RESPONSE;
    }
};

class AuthenticationOk : BackendMessage
{
public:
    void serialize(WriteBuffer & out) const override
    {
        out.write('R');
        writeBinaryBigEndian(size(), out);
        writeBinaryBigEndian(0, out); // specifies that the authentication was successful (by protocol)
    }

    Int32 size() const override
    {
        // length of message + special int32
        return 4 + 4;
    }

    MessageType getMessageType() const override
    {
        return MessageType::AUTHENTICATION_OK;
    }
};

class PasswordMessage : FrontMessage
{
public:
    String password;

    void deserialize(ReadBuffer & in) override
    {
        Int32 sz = 0;
        readBinaryBigEndian(sz, in);
        readNullTerminated(password, in);
    }

    MessageType getMessageType() const override
    {
        return MessageType::PASSWORD_MESSAGE;
    }
};

class ParameterStatus : BackendMessage
{
private:
    String name;
    String value;

public:
    ParameterStatus(String name_, String value_)
    : name(name_)
    , value(value_)
    {}

    void serialize(WriteBuffer & out) const override
    {
        out.write('S');
        writeBinaryBigEndian(size(), out);
        writeNullTerminatedString(name, out);
        writeNullTerminatedString(value, out);
    }

    Int32 size() const override
    {
        return static_cast<Int32>(4 + name.size() + 1 + value.size() + 1);
    }

    MessageType getMessageType() const override
    {
        return MessageType::PARAMETER_STATUS;
    }
};

class BackendKeyData : BackendMessage
{
private:
    Int32 process_id;
    Int32 secret_key;

public:
    BackendKeyData(Int32 process_id_, Int32 secret_key_)
    : process_id(process_id_)
    , secret_key(secret_key_)
    {}

    void serialize(WriteBuffer & out) const override
    {
        out.write('K');
        writeBinaryBigEndian(size(), out);
        writeBinaryBigEndian(process_id, out);
        writeBinaryBigEndian(secret_key, out);
    }

    Int32 size() const override
    {
        return 4 + 4 + 4;
    }

    MessageType getMessageType() const override
    {
        return MessageType::BACKEND_KEY_DATA;
    }
};

class Query : FrontMessage
{
public:
    String query;

    void deserialize(ReadBuffer & in) override
    {
        Int32 sz = 0;
        readBinaryBigEndian(sz, in);
        readNullTerminated(query, in);
    }

    MessageType getMessageType() const override
    {
        return MessageType::QUERY;
    }
};

class ParseQuery : FrontMessage
{
public:
    String function_name;
    String sql_query;
    Int16 num_params{};

    void deserialize(ReadBuffer & in) override
    {
        Int32 sz = 0;
        readBinaryBigEndian(sz, in);
        readNullTerminated(function_name, in);
        readNullTerminated(sql_query, in);
        readBinaryBigEndian(num_params, in);
        Int32 oid_param = 0;
        for (int i = 0; i < num_params; ++i)
            readBinaryBigEndian(oid_param, in);
    }

    MessageType getMessageType() const override
    {
        return MessageType::PARSE;
    }
};

class ParseQueryComplete : BackendMessage
{
public:
    ParseQueryComplete() = default;

    void serialize(WriteBuffer & out) const override
    {
        out.write('1');
        writeBinaryBigEndian(size(), out);
    }

    Int32 size() const override
    {
        return 4;
    }

    MessageType getMessageType() const override
    {
        return MessageType::PARSE_COMPLETE;
    }
};

class BindQuery : FrontMessage
{
public:
    String portal_name;
    String function_name;
    VectorWithMemoryTracking<String> parameters;
    Int16 num_params{};

    void deserialize(ReadBuffer & in) override
    {
        Int32 sz = 0;
        readBinaryBigEndian(sz, in);
        readNullTerminated(portal_name, in);
        readNullTerminated(function_name, in);

        Int16 num_format_params = 0;
        readBinaryBigEndian(num_format_params, in);
        Int16 format_param = 0;
        for (Int16 i = 0; i < num_format_params; ++i)
        {
            readBinaryBigEndian(format_param, in);
        }
        readBinaryBigEndian(num_params, in);
        for (int i = 0; i < num_params; ++i)
        {
            Int32 sz_param = 0;
            readBinaryBigEndian(sz_param, in);
            /// -1 is the protocol sentinel for a NULL parameter and no value bytes follow;
            /// any other negative value is malformed.
            if (sz_param < -1)
                throw Exception(ErrorCodes::UNKNOWN_PACKET_FROM_CLIENT,
                                "Wrong parameter length {} in Bind message, it must not be less than -1", sz_param);
            if (sz_param == -1)
            {
                parameters.emplace_back("NULL");
                continue;
            }
            String current_param(sz_param, 0);
            in.readStrict(current_param.data(), sz_param);
            parameters.push_back(current_param);
        }

        Int16 num_format_params_result = 0;
        readBinaryBigEndian(num_format_params_result, in);
        Int16 format_param_result = 0;
        for (Int16 i = 0; i < num_format_params_result; ++i)
            readBinaryBigEndian(format_param_result, in);
    }

    MessageType getMessageType() const override
    {
        return MessageType::BIND;
    }
};

class BindQueryComplete : BackendMessage
{
public:
    BindQueryComplete() = default;

    void serialize(WriteBuffer & out) const override
    {
        out.write('2');
        writeBinaryBigEndian(size(), out);
    }

    Int32 size() const override
    {
        return 4;
    }

    MessageType getMessageType() const override
    {
        return MessageType::BIND_COMPLETE;
    }
};

class DescribeQuery : FrontMessage
{
public:
    char describe{};
    String function_name;

    void deserialize(ReadBuffer & in) override
    {
        Int32 sz = 0;
        readBinaryBigEndian(sz, in);
        in.readStrict(&describe, 1);
        readNullTerminated(function_name, in);
    }

    MessageType getMessageType() const override
    {
        return MessageType::DESCRIBE;
    }

};

class ExecuteQuery : FrontMessage
{
public:
    String portal_name;
    Int32 max_rows{};

    void deserialize(ReadBuffer & in) override
    {
        Int32 sz = 0;
        readBinaryBigEndian(sz, in);
        readNullTerminated(portal_name, in);
        readBinaryBigEndian(max_rows, in);
    }

    MessageType getMessageType() const override
    {
        return MessageType::BIND;
    }

};

class EmptyQueryResponse : public BackendMessage
{
public:
    void serialize(WriteBuffer & out) const override
    {
        out.write('I');
        writeBinaryBigEndian(size(), out);
    }

    Int32 size() const override
    {
        return 4;
    }

    MessageType getMessageType() const override
    {
        return MessageType::EMPTY_QUERY_RESPONSE;
    }
};

enum class FormatCode : Int16
{
    TEXT = 0,
    BINARY = 1,
};

class CloseQuery : FrontMessage
{
public:
    String function_name;
    /// 'S' for prepared statement, 'P' for portal
    char close_target = 0;

    void deserialize(ReadBuffer & in) override
    {
        Int32 sz = 0;
        readBinaryBigEndian(sz, in);
        Int8 byte = 0;
        readBinaryBigEndian(byte, in);
        close_target = static_cast<char>(byte);
        readNullTerminated(function_name, in);
    }

    MessageType getMessageType() const override
    {
        return MessageType::CLOSE;
    }
};

class CloseQueryComplete : BackendMessage
{
public:
    CloseQueryComplete() = default;

    void serialize(WriteBuffer & out) const override
    {
        /// 'C' is `CommandComplete`; `CloseComplete` is tagged with '3' per
        /// the PostgreSQL message protocol.
        out.write('3');
        writeBinaryBigEndian(size(), out);
    }

    Int32 size() const override
    {
        return 4;
    }

    MessageType getMessageType() const override
    {
        return MessageType::CLOSE_COMPLETE;
    }
};

class SyncQuery : FrontMessage
{
public:
    void deserialize(ReadBuffer & in) override
    {
        Int32 sz = 0;
        readBinaryBigEndian(sz, in);
    }

    MessageType getMessageType() const override
    {
        return MessageType::SYNC;
    }
};

class FieldDescription : ISerializable
{
private:
    const String & name;
    ColumnTypeSpec type_spec;
    FormatCode format_code;

public:
    FieldDescription(const String & name_, const DataTypePtr & data_type, FormatCode format_code_ = FormatCode::TEXT)
    : name(name_)
    , type_spec(convertDataTypeToPostgresColumnTypeSpec(data_type))
    , format_code(format_code_)
    {}

    void serialize(WriteBuffer & out) const override
    {
        writeNullTerminatedString(name, out);
        writeBinaryBigEndian(static_cast<Int32>(0), out);
        writeBinaryBigEndian(static_cast<Int16>(0), out);
        writeBinaryBigEndian(static_cast<Int32>(type_spec.type), out);
        writeBinaryBigEndian(type_spec.len, out);
        writeBinaryBigEndian(static_cast<Int32>(-1), out);
        writeBinaryBigEndian(static_cast<Int16>(format_code), out);
    }

    Int32 size() const override
    {
        // size of name (C string)
        // + object ID of the table (Int32 and always zero) + attribute number of the column (Int16 and always zero)
        // + type object id (Int32) + data type size (Int16)
        // + type modifier (Int32 and always -1) + format code (Int16)
        return static_cast<Int32>((name.size() + 1) + 4 + 2 + 4 + 2 + 4 + 2);
    }