#pragma once

#include <cstddef>

#include <cstdint>

#include <memory>

#include <string>

#include <string_view>

#include <utility>

#include <vector>

#include "arrow/flight/visibility.h"

#include "arrow/ipc/options.h"

#include "arrow/ipc/writer.h"

#include "arrow/result.h"

namespace arrow {

class Buffer;

class RecordBatch;

class Schema;

class Status;

class Table;

namespace ipc {

class DictionaryMemo;

} // namespace ipc

namespace internal {

class Uri;

} // namespace internal

namespace flight {

enum class FlightStatusCode : int8_t {

};

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable : 4275)

#endif

class ARROW_FLIGHT_EXPORT FlightStatusDetail : public arrow::StatusDetail {

public:

explicit FlightStatusDetail(FlightStatusCode code) : code_{code} {}

explicit FlightStatusDetail(FlightStatusCode code, std::string extra_info)

: code_{code}, extra_info_(std::move(extra_info)) {}

const char* type_id() const override;

std::string ToString() const override;

/// \brief Get the Flight status code.

FlightStatusCode code() const;

/// \brief Get the extra error info

std::string extra_info() const;

/// \brief Get the human-readable name of the status code.

std::string CodeAsString() const;

/// \brief Set the extra error info

void set_extra_info(std::string extra_info);

/// \brief Try to extract a \a FlightStatusDetail from any Arrow

/// status.

///

/// \return a \a FlightStatusDetail if it could be unwrapped, \a

/// nullptr otherwise

static std::shared_ptr<FlightStatusDetail> UnwrapStatus(const arrow::Status& status);

private:

FlightStatusCode code_;

std::string extra_info_;

};

#ifdef _MSC_VER

#pragma warning(pop)

#endif

Status MakeFlightError(FlightStatusCode code, std::string message,

std::string extra_info = {});

struct ARROW_FLIGHT_EXPORT CertKeyPair {

/// \brief The certificate in PEM format.

std::string pem_cert;

/// \brief The key in PEM format.

std::string pem_key;

};

struct ARROW_FLIGHT_EXPORT ActionType {

/// \brief The name of the action.

std::string type;

/// \brief A human-readable description of the action.

std::string description;

bool Equals(const ActionType& other) const;

friend bool operator==(const ActionType& left, const ActionType& right) {

return left.Equals(right);

}

friend bool operator!=(const ActionType& left, const ActionType& right) {

return !(left == right);

}

/// \brief Serialize this message to its wire-format representation.

arrow::Result<std::string> SerializeToString() const;

/// \brief Deserialize this message from its wire-format representation.

static arrow::Result<ActionType> Deserialize(std::string_view serialized);

};

struct ARROW_FLIGHT_EXPORT Criteria {

/// Opaque criteria expression, dependent on server implementation

std::string expression;

bool Equals(const Criteria& other) const;

friend bool operator==(const Criteria& left, const Criteria& right) {

return left.Equals(right);

}

friend bool operator!=(const Criteria& left, const Criteria& right) {

return !(left == right);

}

/// \brief Serialize this message to its wire-format representation.

arrow::Result<std::string> SerializeToString() const;

/// \brief Deserialize this message from its wire-format representation.

static arrow::Result<Criteria> Deserialize(std::string_view serialized);

};

struct ARROW_FLIGHT_EXPORT Action {

/// The action type

std::string type;

/// The action content as a Buffer

std::shared_ptr<Buffer> body;

bool Equals(const Action& other) const;

friend bool operator==(const Action& left, const Action& right) {

return left.Equals(right);

}

friend bool operator!=(const Action& left, const Action& right) {

return !(left == right);

}

/// \brief Serialize this message to its wire-format representation.

arrow::Result<std::string> SerializeToString() const;

/// \brief Deserialize this message from its wire-format representation.

static arrow::Result<Action> Deserialize(std::string_view serialized);

};

struct ARROW_FLIGHT_EXPORT Result {

std::shared_ptr<Buffer> body;

bool Equals(const Result& other) const;

friend bool operator==(const Result& left, const Result& right) {

return left.Equals(right);

}

friend bool operator!=(const Result& left, const Result& right) {

return !(left == right);

}

/// \brief Serialize this message to its wire-format representation.

arrow::Result<std::string> SerializeToString() const;

/// \brief Deserialize this message from its wire-format representation.

static arrow::Result<Result> Deserialize(std::string_view serialized);

};

struct ARROW_FLIGHT_EXPORT BasicAuth {

std::string username;

std::string password;

bool Equals(const BasicAuth& other) const;

friend bool operator==(const BasicAuth& left, const BasicAuth& right) {

return left.Equals(right);

}

friend bool operator!=(const BasicAuth& left, const BasicAuth& right) {

return !(left == right);

}

/// \brief Deserialize this message from its wire-format representation.

static arrow::Result<BasicAuth> Deserialize(std::string_view serialized);

/// \brief Serialize this message to its wire-format representation.

arrow::Result<std::string> SerializeToString() const;

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

static Status Deserialize(const std::string& serialized, BasicAuth* out);

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

static Status Serialize(const BasicAuth& basic_auth, std::string* out);

};

struct ARROW_FLIGHT_EXPORT FlightDescriptor {

enum DescriptorType {

};

/// The descriptor type

DescriptorType type;

/// Opaque value used to express a command. Should only be defined when type

/// is CMD

std::string cmd;

/// List of strings identifying a particular dataset. Should only be defined

/// when type is PATH

std::vector<std::string> path;

bool Equals(const FlightDescriptor& other) const;

/// \brief Get a human-readable form of this descriptor.

std::string ToString() const;

/// \brief Get the wire-format representation of this type.

///

/// Useful when interoperating with non-Flight systems (e.g. REST

/// services) that may want to return Flight types.

arrow::Result<std::string> SerializeToString() const;

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

Status SerializeToString(std::string* out) const;

/// \brief Parse the wire-format representation of this type.

///

/// Useful when interoperating with non-Flight systems (e.g. REST

/// services) that may want to return Flight types.

static arrow::Result<FlightDescriptor> Deserialize(std::string_view serialized);

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

static Status Deserialize(const std::string& serialized, FlightDescriptor* out);

// Convenience factory functions

static FlightDescriptor Command(const std::string& c) {

return FlightDescriptor{CMD, c, {}};

}

static FlightDescriptor Path(const std::vector<std::string>& p) {

return FlightDescriptor{PATH, "", p};

}

friend bool operator==(const FlightDescriptor& left, const FlightDescriptor& right) {

return left.Equals(right);

}

friend bool operator!=(const FlightDescriptor& left, const FlightDescriptor& right) {

return !(left == right);

}

};

struct ARROW_FLIGHT_EXPORT Ticket {

std::string ticket;

bool Equals(const Ticket& other) const;

friend bool operator==(const Ticket& left, const Ticket& right) {

return left.Equals(right);

}

friend bool operator!=(const Ticket& left, const Ticket& right) {

return !(left == right);

}

/// \brief Get the wire-format representation of this type.

///

/// Useful when interoperating with non-Flight systems (e.g. REST

/// services) that may want to return Flight types.

arrow::Result<std::string> SerializeToString() const;

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

Status SerializeToString(std::string* out) const;

/// \brief Parse the wire-format representation of this type.

///

/// Useful when interoperating with non-Flight systems (e.g. REST

/// services) that may want to return Flight types.

static arrow::Result<Ticket> Deserialize(std::string_view serialized);

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

static Status Deserialize(const std::string& serialized, Ticket* out);

};

class FlightClient;

class FlightServerBase;

extern const char* kSchemeGrpc;

extern const char* kSchemeGrpcTcp;

extern const char* kSchemeGrpcUnix;

extern const char* kSchemeGrpcTls;

struct ARROW_FLIGHT_EXPORT Location {

public:

/// \brief Initialize a blank location.

Location();

/// \brief Initialize a location by parsing a URI string

static arrow::Result<Location> Parse(const std::string& uri_string);

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

static Status Parse(const std::string& uri_string, Location* location);

/// \brief Initialize a location for a non-TLS, gRPC-based Flight

/// service from a host and port

/// \param[in] host The hostname to connect to

/// \param[in] port The port

/// \return Arrow result with the resulting location

static arrow::Result<Location> ForGrpcTcp(const std::string& host, const int port);

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

static Status ForGrpcTcp(const std::string& host, const int port, Location* location);

/// \brief Initialize a location for a TLS-enabled, gRPC-based Flight

/// service from a host and port

/// \param[in] host The hostname to connect to

/// \param[in] port The port

/// \return Arrow result with the resulting location

static arrow::Result<Location> ForGrpcTls(const std::string& host, const int port);

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

static Status ForGrpcTls(const std::string& host, const int port, Location* location);

/// \brief Initialize a location for a domain socket-based Flight

/// service

/// \param[in] path The path to the domain socket

/// \return Arrow result with the resulting location

static arrow::Result<Location> ForGrpcUnix(const std::string& path);

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

static Status ForGrpcUnix(const std::string& path, Location* location);

/// \brief Initialize a location based on a URI scheme

static arrow::Result<Location> ForScheme(const std::string& scheme,

const std::string& host, const int port);

/// \brief Get a representation of this URI as a string.

std::string ToString() const;

/// \brief Get the scheme of this URI.

std::string scheme() const;

bool Equals(const Location& other) const;

friend bool operator==(const Location& left, const Location& right) {

return left.Equals(right);

}

friend bool operator!=(const Location& left, const Location& right) {

return !(left == right);

}

private:

friend class FlightClient;

friend class FlightServerBase;

std::shared_ptr<arrow::internal::Uri> uri_;

};

struct ARROW_FLIGHT_EXPORT FlightEndpoint {

/// Opaque ticket identify; use with DoGet RPC

Ticket ticket;

/// List of locations where ticket can be redeemed. If the list is empty, the

/// ticket can only be redeemed on the current service where the ticket was

/// generated

std::vector<Location> locations;

bool Equals(const FlightEndpoint& other) const;

friend bool operator==(const FlightEndpoint& left, const FlightEndpoint& right) {

return left.Equals(right);

}

friend bool operator!=(const FlightEndpoint& left, const FlightEndpoint& right) {

return !(left == right);

}

/// \brief Serialize this message to its wire-format representation.

arrow::Result<std::string> SerializeToString() const;

/// \brief Deserialize this message from its wire-format representation.

static arrow::Result<FlightEndpoint> Deserialize(std::string_view serialized);

};

struct ARROW_FLIGHT_EXPORT FlightPayload {

std::shared_ptr<Buffer> descriptor;

std::shared_ptr<Buffer> app_metadata;

ipc::IpcPayload ipc_message;

/// \brief Check that the payload can be written to the wire.

Status Validate() const;

};

struct ARROW_FLIGHT_EXPORT SchemaResult {

public:

SchemaResult() = default;

explicit SchemaResult(std::string schema) : raw_schema_(std::move(schema)) {}

/// \brief Factory method to construct a SchemaResult.

static arrow::Result<std::unique_ptr<SchemaResult>> Make(const Schema& schema);

/// \brief return schema

/// \param[in,out] dictionary_memo for dictionary bookkeeping, will

/// be modified

/// \return Arrrow result with the reconstructed Schema

arrow::Result<std::shared_ptr<Schema>> GetSchema(

ipc::DictionaryMemo* dictionary_memo) const;

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

Status GetSchema(ipc::DictionaryMemo* dictionary_memo,

std::shared_ptr<Schema>* out) const;

const std::string& serialized_schema() const { return raw_schema_; }

bool Equals(const SchemaResult& other) const;

friend bool operator==(const SchemaResult& left, const SchemaResult& right) {

return left.Equals(right);

}

friend bool operator!=(const SchemaResult& left, const SchemaResult& right) {

return !(left == right);

}

/// \brief Serialize this message to its wire-format representation.

arrow::Result<std::string> SerializeToString() const;

/// \brief Deserialize this message from its wire-format representation.

static arrow::Result<SchemaResult> Deserialize(std::string_view serialized);

private:

std::string raw_schema_;

};

class ARROW_FLIGHT_EXPORT FlightInfo {

public:

struct Data {

};

explicit FlightInfo(const Data& data) : data_(data), reconstructed_schema_(false) {}

explicit FlightInfo(Data&& data)

: data_(std::move(data)), reconstructed_schema_(false) {}

/// \brief Factory method to construct a FlightInfo.

static arrow::Result<FlightInfo> Make(const Schema& schema,

const FlightDescriptor& descriptor,

const std::vector<FlightEndpoint>& endpoints,

int64_t total_records, int64_t total_bytes);

/// \brief Deserialize the Arrow schema of the dataset. Populate any

/// dictionary encoded fields into a DictionaryMemo for

/// bookkeeping

/// \param[in,out] dictionary_memo for dictionary bookkeeping, will

/// be modified

/// \return Arrrow result with the reconstructed Schema

arrow::Result<std::shared_ptr<Schema>> GetSchema(

ipc::DictionaryMemo* dictionary_memo) const;

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

Status GetSchema(ipc::DictionaryMemo* dictionary_memo,

std::shared_ptr<Schema>* out) const;

const std::string& serialized_schema() const { return data_.schema; }

/// The descriptor associated with this flight, may not be set

const FlightDescriptor& descriptor() const { return data_.descriptor; }

/// A list of endpoints associated with the flight (dataset). To consume the

/// whole flight, all endpoints must be consumed

const std::vector<FlightEndpoint>& endpoints() const { return data_.endpoints; }

/// The total number of records (rows) in the dataset. If unknown, set to -1

int64_t total_records() const { return data_.total_records; }

/// The total number of bytes in the dataset. If unknown, set to -1

int64_t total_bytes() const { return data_.total_bytes; }

/// \brief Get the wire-format representation of this type.

///

/// Useful when interoperating with non-Flight systems (e.g. REST

/// services) that may want to return Flight types.

arrow::Result<std::string> SerializeToString() const;

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

Status SerializeToString(std::string* out) const;

/// \brief Parse the wire-format representation of this type.

///

/// Useful when interoperating with non-Flight systems (e.g. REST

/// services) that may want to return Flight types.

static arrow::Result<std::unique_ptr<FlightInfo>> Deserialize(

std::string_view serialized);

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

static Status Deserialize(const std::string& serialized,

std::unique_ptr<FlightInfo>* out);

private:

Data data_;

mutable std::shared_ptr<Schema> schema_;

mutable bool reconstructed_schema_;

};

class ARROW_FLIGHT_EXPORT FlightListing {

public:

virtual ~FlightListing() = default;

/// \brief Retrieve the next FlightInfo from the iterator.

/// \return Arrow result with a single FlightInfo. Set to \a nullptr if there

/// are none left.

virtual arrow::Result<std::unique_ptr<FlightInfo>> Next() = 0;

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

Status Next(std::unique_ptr<FlightInfo>* info);

};

class ARROW_FLIGHT_EXPORT ResultStream {

public:

virtual ~ResultStream() = default;

/// \brief Retrieve the next Result from the iterator.

/// \return Arrow result with a single Result. Set to \a nullptr if there are none left.

virtual arrow::Result<std::unique_ptr<Result>> Next() = 0;

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

Status Next(std::unique_ptr<Result>* info);

};

struct ARROW_FLIGHT_EXPORT FlightStreamChunk {

public:

std::shared_ptr<RecordBatch> data;

std::shared_ptr<Buffer> app_metadata;

};

class ARROW_FLIGHT_EXPORT MetadataRecordBatchReader {

public:

virtual ~MetadataRecordBatchReader() = default;

/// \brief Get the schema for this stream.

virtual arrow::Result<std::shared_ptr<Schema>> GetSchema() = 0;

/// \brief Get the next message from Flight. If the stream is

/// finished, then the members of \a FlightStreamChunk will be

/// nullptr.

virtual arrow::Result<FlightStreamChunk> Next() = 0;

ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")

Status Next(FlightStreamChunk* next);

/// \brief Consume entire stream as a vector of record batches

virtual arrow::Result<std::vector<std::shared_ptr<RecordBatch>>> ToRecordBatches();

ARROW_DEPRECATED("Deprecated in 8.0.0. Use ToRecordBatches instead.")

Status ReadAll(std::vector<std::shared_ptr<RecordBatch>>* batches);

/// \brief Consume entire stream as a Table

virtual arrow::Result<std::shared_ptr<Table>> ToTable();

ARROW_DEPRECATED("Deprecated in 8.0.0. Use ToTable instead.")

Status ReadAll(std::shared_ptr<Table>* table);

};

arrow::Result<std::shared_ptr<RecordBatchReader>> MakeRecordBatchReader(

std::shared_ptr<MetadataRecordBatchReader> reader);

class ARROW_FLIGHT_EXPORT MetadataRecordBatchWriter : public ipc::RecordBatchWriter {

public:

virtual ~MetadataRecordBatchWriter() = default;

/// \brief Begin writing data with the given schema. Only used with \a DoExchange.

virtual Status Begin(const std::shared_ptr<Schema>& schema,

const ipc::IpcWriteOptions& options) = 0;

virtual Status Begin(const std::shared_ptr<Schema>& schema);

virtual Status WriteMetadata(std::shared_ptr<Buffer> app_metadata) = 0;

virtual Status WriteWithMetadata(const RecordBatch& batch,

std::shared_ptr<Buffer> app_metadata) = 0;

};

class ARROW_FLIGHT_EXPORT SimpleFlightListing : public FlightListing {

public:

explicit SimpleFlightListing(const std::vector<FlightInfo>& flights);

explicit SimpleFlightListing(std::vector<FlightInfo>&& flights);

arrow::Result<std::unique_ptr<FlightInfo>> Next() override;

private:

int position_;

std::vector<FlightInfo> flights_;

};

class ARROW_FLIGHT_EXPORT SimpleResultStream : public ResultStream {

public:

explicit SimpleResultStream(std::vector<Result>&& results);

arrow::Result<std::unique_ptr<Result>> Next() override;

private:

std::vector<Result> results_;

size_t position_;

};

} // namespace flight

} // namespace arrow