Messages

struct ErrorResponse {
  // Message type ('E').
  uint8           mtype = 0x45;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Message severity.
  uint8<ErrorSeverity> severity;

  // Message code.
  uint32          error_code;

  // Error message.
  string          message;

  // Error attributes.
  uint16          num_attributes;
  Header          attributes[num_attributes];
};

enum ErrorSeverity {
  ERROR           = 0x78;
  FATAL           = 0xc8;
  PANIC           = 0xff;
};

struct LogMessage {
  // Message type ('L').
  uint8           mtype = 0x4c;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Message severity.
  uint8<MessageSeverity> severity;

  // Message code.
  uint32          code;

  // Message text.
  string          text;

  // Message attributes.
  uint16          num_attributes;
  Header          attributes[num_attributes];
};

enum MessageSeverity {
  DEBUG           = 0x14;
  INFO            = 0x28;
  NOTICE          = 0x3c;
  WARNING         = 0x50;
};

struct ReadyForCommand {
  // Message type ('Z').
  uint8           mtype = 0x5a;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Transaction state.
  uint8<TransactionState> transaction_state;
};

enum TransactionState {
  NOT_IN_TRANSACTION = 0x49;
  IN_TRANSACTION  = 0x54;
  IN_FAILED_TRANSACTION = 0x45;
};

struct RestoreReady {
  // Message type ('+').
  uint8           mtype = 0x2b;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Number of parallel jobs for restore,
  // currently always "1"
  uint16          jobs;
};

struct CommandComplete {
  // Message type ('C').
  uint8           mtype = 0x43;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Command status.
  string          status;
};

struct ExecuteScript {
  // Message type ('Q').
  uint8           mtype = 0x51;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // EdgeQL script text to execute.
  string          script;
};

struct Prepare {
  // Message type ('P').
  uint8           mtype = 0x50;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Data I/O format.
  uint8<IOFormat> io_format;

  // Expected result cardinality
  uint8<Cardinality> expected_cardinality;

  // Prepared statement name. Currently must
  // be empty.
  bytes           statement_name;

  // Command text.
  string          command;
};

enum IOFormat {
  BINARY          = 0x62;
  JSON            = 0x6a;
  JSON_ELEMENTS   = 0x4a;
};

enum Cardinality {
  NO_RESULT       = 0x6e;
  ONE             = 0x6f;
  MANY            = 0x6d;
};

struct DescribeStatement {
  // Message type ('D').
  uint8           mtype = 0x44;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Aspect to describe.
  uint8<DescribeAspect> aspect;

  // The name of the statement.
  bytes           statement_name;
};

enum DescribeAspect {
  DATA_DESCRIPTION = 0x54;
};

struct Dump {
  // Message type ('>').
  uint8           mtype = 0x3e;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];
};

struct CommandDataDescription {
  // Message type ('T').
  uint8           mtype = 0x54;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Actual result cardinality.
  uint8<Cardinality> result_cardinality;

  // Argument data descriptor ID.
  uuid            input_typedesc_id;

  // Argument data descriptor.
  bytes           input_typedesc;

  // Output data descriptor ID.
  uuid            output_typedesc_id;

  // Output data descriptor.
  bytes           output_typedesc;
};

enum Cardinality {
  NO_RESULT       = 0x6e;
  ONE             = 0x6f;
  MANY            = 0x6d;
};

struct Sync {
  // Message type ('S').
  uint8           mtype = 0x53;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;
};

struct Flush {
  // Message type ('H').
  uint8           mtype = 0x48;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;
};

struct Execute {
  // Message type ('E').
  uint8           mtype = 0x45;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Prepared statement name.
  bytes           statement_name;

  // Encoded argument data.
  bytes           arguments;
};

struct Restore {
  // Message type ('<').
  uint8           mtype = 0x3c;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Number of parallel jobs for restore
  // (only "1" is supported)
  uint16          jobs;

  // Original DumpHeader packet data
  // excluding mtype and message_length
  bytes           header_data;
};

struct RestoreBlock {
  // Message type ('=').
  uint8           mtype = 0x3d;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Original DumpBlock packet data excluding
  // mtype and message_length
  bytes           block_data;
};

struct RestoreEof {
  // Message type ('.').
  uint8           mtype = 0x2e;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;
};

struct OptimisticExecute {
  // Message type ('O').
  uint8           mtype = 0x4f;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Data I/O format.
  uint8<IOFormat> io_format;

  // Expected result cardinality.
  uint8<Cardinality> expected_cardinality;

  // Command text.
  string          command_text;

  // Argument data descriptor ID.
  uuid            input_typedesc_id;

  // Output data descriptor ID.
  uuid            output_typedesc_id;

  // Encoded argument data.
  bytes           arguments;
};

struct Data {
  // Message type ('D').
  uint8           mtype = 0x44;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Encoded output data array. The array is
  // currently always of size 1.
  uint16          num_data;
  DataElement     data[num_data];
};

struct DataElement {
  // Encoded output data.
  uint32          num_data;
  uint8           data[num_data];
};

struct DumpHeader {
  // Message type ('@').
  uint8           mtype = 0x40;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Major version of EdgeDB.
  uint16          major_ver;

  // Minor version of EdgeDB.
  uint16          minor_ver;

  // Schema.
  string          schema_ddl;

  // Type identifiers.
  uint32          num_types;
  DumpTypeInfo    types[num_types];

  // Object descriptors.
  uint32          num_descriptors;
  DumpObjectDesc  descriptors[num_descriptors];
};

struct DumpTypeInfo {
  string          type_name;

  string          type_class;

  uuid            type_id;
};

struct DumpObjectDesc {
  uuid            object_id;

  bytes           description;

  uint16          num_dependencies;
  uuid            dependencies[num_dependencies];
};

struct DumpBlock {
  // Message type ('=').
  uint8           mtype = 0x3d;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];
};

struct ServerKeyData {
  // Message type ('K').
  uint8           mtype = 0x4b;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Key data.
  uint8           data[32];
};

struct ParameterStatus {
  // Message type ('S').
  uint8           mtype = 0x53;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Parameter name.
  bytes           name;

  // Parameter value.
  bytes           value;
};

struct PrepareComplete {
  // Message type ('1').
  uint8           mtype = 0x31;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // A set of message headers.
  uint16          num_headers;
  Header          headers[num_headers];

  // Result cardinality.
  uint8<Cardinality> cardinality;

  // Argument data descriptor ID.
  uuid            input_typedesc_id;

  // Result data descriptor ID.
  uuid            output_typedesc_id;
};

enum Cardinality {
  NO_RESULT       = 0x6e;
  ONE             = 0x6f;
  MANY            = 0x6d;
};

struct ClientHandshake {
  // Message type ('V').
  uint8           mtype = 0x56;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Requested protocol major version.
  uint16          major_ver;

  // Requested protocol minor version.
  uint16          minor_ver;

  // Connection parameters.
  uint16          num_params;
  ConnectionParam params[num_params];

  // Requested protocol extensions.
  uint16          num_extensions;
  ProtocolExtension extensions[num_extensions];
};

struct ConnectionParam {
  string          name;

  string          value;
};

struct ProtocolExtension {
  // Extension name.
  string          name;

  // A set of extension headers.
  uint16          num_headers;
  Header          headers[num_headers];
};

struct ServerHandshake {
  // Message type ('v').
  uint8           mtype = 0x76;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // maximum supported or client-requested
  // protocol major version, whichever is
  // greater.
  uint16          major_ver;

  // maximum supported or client-requested
  // protocol minor version, whichever is
  // greater.
  uint16          minor_ver;

  // Supported protocol extensions.
  uint16          num_extensions;
  ProtocolExtension extensions[num_extensions];
};

struct ProtocolExtension {
  // Extension name.
  string          name;

  // A set of extension headers.
  uint16          num_headers;
  Header          headers[num_headers];
};

struct AuthenticationOK {
  // Message type ('R').
  uint8           mtype = 0x52;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Specifies that this message contains a
  // successful authentication indicator.
  uint32          auth_status;
};

struct AuthenticationRequiredSASLMessage {
  // Message type ('R').
  uint8           mtype = 0x52;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Specifies that this message contains a
  // SASL authentication request.
  uint32          auth_status = 0xa;

  // A list of supported SASL authentication
  // methods.
  uint32          num_methods;
  string          methods[num_methods];
};

struct AuthenticationSASLContinue {
  // Message type ('R').
  uint8           mtype = 0x52;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Specifies that this message contains a
  // SASL challenge.
  uint32          auth_status = 0xb;

  // Mechanism-specific SASL data.
  bytes           sasl_data;
};

struct AuthenticationSASLFinal {
  // Message type ('R').
  uint8           mtype = 0x52;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Specifies that SASL authentication has
  // completed.
  uint32          auth_status = 0xc;

  bytes           sasl_data;
};

struct AuthenticationSASLInitialResponse {
  // Message type ('p').
  uint8           mtype = 0x70;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Name of the SASL authentication
  // mechanism that the client selected.
  string          method;

  // Mechanism-specific "Initial Response"
  // data.
  bytes           sasl_data;
};

struct AuthenticationSASLResponse {
  // Message type ('r').
  uint8           mtype = 0x72;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;

  // Mechanism-specific response data.
  bytes           sasl_data;
};

struct Terminate {
  // Message type ('X').
  uint8           mtype = 0x58;

  // Length of message contents in bytes,
  // including self.
  uint32          message_length;
};