storages::mysql::StatementResultSet Class Reference

Table of Contents

• Public Member Functions
• Friends
• Detailed Description
• Member Function Documentation
• AsContainer() [1/2]
• AsContainer() [2/2]
• AsOptionalSingleField()
• AsOptionalSingleRow()
• AsSingleField()
• AsSingleRow()
• AsVector() [1/2]
• AsVector() [2/2]
• MapFrom()
• Friends And Related Symbol Documentation
• CursorResultSet
• MappedStatementResultSet

A wrapper for statement execution result. More...

#include </data/code/service_template/third_party/userver/mysql/include/userver/storages/mysql/statement_result_set.hpp>

Public Member Functions
	StatementResultSet (impl::StatementFetcher &&fetcher, tracing::Span &&span)
	StatementResultSet (infra::ConnectionPtr &&connection, impl::StatementFetcher &&fetcher, tracing::Span &&span)
	StatementResultSet (const StatementResultSet &other)=delete
	StatementResultSet (StatementResultSet &&other) noexcept
template<typename T >
std::vector< T >	AsVector () &&
	Parse statement result set as std::vector<T>. T is expected to be an aggregate of supported types. See MySQL supported types for better understanding of T requirements.
template<typename T >
std::vector< T >	AsVector (FieldTag) &&
	Parse statement result set as std::vector<T>. Result set is expected to have a single column, T is expected to be one of supported types. See MySQL supported types for supported typed.
template<typename Container >
Container	AsContainer () &&
	Parse statement result set as Container<T>. T is expected to be an aggregate of supported types, Container is expected to meet std::Container requirements. See MySQL supported types for better understanding of Container::value_type requirements.
template<typename Container >
Container	AsContainer (FieldTag) &&
	Parse statement result as Container<T>. Result set is expected to have a single column, T is expected to be one of supported types, Container is expected to meed std::Container requirements. See MySQL supported types for supported types.
template<typename T >
T	AsSingleRow () &&
	Parse statement result as T. Result set is expected to have a single row, T is expected to be an aggregate of supported types. See MySQL supported types for better understanding of T requirements.
template<typename T >
T	AsSingleField () &&
	Parse statement result as T. Result set is expected to have a single row and a single column, T is expected to be one of supported types. See MySQL supported types for supported types.
template<typename T >
std::optional< T >	AsOptionalSingleRow () &&
	Parse statement result as std::optional<T>. Result set is expected to have not more than one row, T is expected to be an aggregate of supported types. See MySQL supported types for better understanding of T requirements.
template<typename T >
std::optional< T >	AsOptionalSingleField () &&
	Parse statement result as T. Result set is expected to have not more than one row, T is expected to be one of supported types. See MySQL supported types for supported types.
template<typename DbType >
MappedStatementResultSet< DbType >	MapFrom () &&
	Converts to an interface for on-the-flight mapping statement result set from DbType. DbType is expected to be an aggregate of supported types. See MySQL supported types for better understanding of DbType requirements.
ExecutionResult	AsExecutionResult () &&
	Get statement execution metadata.

Friends
template<typename T >
class	CursorResultSet
template<typename DbType >
class	MappedStatementResultSet

Detailed Description

A wrapper for statement execution result.

This type can't be constructed in user code and is always retrieved from storages::mysql::Cluster or storages::mysql::Transaction methods.

Definition at line 37 of file statement_result_set.hpp.

Member Function Documentation

AsContainer() [1/2]

template<typename Container >

Container storages::mysql::StatementResultSet::AsContainer

(

)

&&

Parse statement result set as Container<T>. T is expected to be an aggregate of supported types, Container is expected to meet std::Container requirements. See MySQL supported types for better understanding of Container::value_type requirements.

UINVARIANTs on columns count mismatch or types mismatch.

struct SampleRow final {
  std::int32_t id;
  std::string value;
 
  bool operator<(const SampleRow& other) const {
    return id < other.id || (id == other.id && value < other.value);
  }
  bool operator==(const SampleRow& other) const {
    return id == other.id && value == other.value;
  }
};
 
void PerformAsContainer(const Cluster& cluster,
                        const std::vector<SampleRow>& data) {
  cluster.ExecuteBulk(ClusterHostType::kPrimary,
                      "INSERT INTO SampleTable(id, value) VALUES(?, ?)", data);
 
  const auto set_or_rows = cluster
                               .Execute(ClusterHostType::kPrimary,
                                        "SELECT id, value FROM SampleTable")
                               .AsContainer<std::set<SampleRow>>();
 
  static_assert(
      std::is_same_v<const std::set<SampleRow>, decltype(set_or_rows)>);
  const auto input_as_set = std::set<SampleRow>{data.begin(), data.end()};
  EXPECT_EQ(set_or_rows, input_as_set);
}

Definition at line 276 of file statement_result_set.hpp.

AsContainer() [2/2]

template<typename Container >

Container storages::mysql::StatementResultSet::AsContainer

(

FieldTag

)

&&

Parse statement result as Container<T>. Result set is expected to have a single column, T is expected to be one of supported types, Container is expected to meed std::Container requirements. See MySQL supported types for supported types.

UINVARIANTs on columns count not being equal to 1 or type mismatch.

void PerformAsContainerField(const Cluster& cluster) {
  cluster.Execute(ClusterHostType::kPrimary,
                  "INSERT INTO SampleTable(id, value) VALUES(?, ?)", 1,
                  "some value");
 
  const auto set_of_values =
      cluster
          .Execute(ClusterHostType::kPrimary, "SELECT value FROM SampleTable")
          .AsContainer<std::set<std::string>>(kFieldTag);
 
  static_assert(
      std::is_same_v<const std::set<std::string>, decltype(set_of_values)>);
  ASSERT_EQ(set_of_values.size(), 1);
  EXPECT_EQ(*set_of_values.begin(), "some value");
}

Definition at line 285 of file statement_result_set.hpp.

AsOptionalSingleField()

template<typename T >

std::optional< T > storages::mysql::StatementResultSet::AsOptionalSingleField

(

)

&&

Parse statement result as T. Result set is expected to have not more than one row, T is expected to be one of supported types. See MySQL supported types for supported types.

UINVARIANTs on columns count not being equal to 1 or type mismatch. throws if result set contains more than one row.

void PerformAsOptionalSingleField(const Cluster& cluster) {
  const auto field_optional =
      cluster
          .Execute(ClusterHostType::kPrimary, "SELECT value FROM SampleTable")
          .AsOptionalSingleField<std::string>();
 
  static_assert(std::is_same_v<const std::optional<std::string>,
                               decltype(field_optional)>);
  EXPECT_FALSE(field_optional.has_value());
}

Definition at line 321 of file statement_result_set.hpp.

AsOptionalSingleRow()

template<typename T >

std::optional< T > storages::mysql::StatementResultSet::AsOptionalSingleRow

(

)

&&

Parse statement result as std::optional<T>. Result set is expected to have not more than one row, T is expected to be an aggregate of supported types. See MySQL supported types for better understanding of T requirements.

UINVARIANTs on columns count mismatch or types mismatch. throws if result set contains more than one row.

struct SampleRow final {
  std::int32_t id;
  std::string value;
};
 
void PerformAsOptionalSingleRow(const Cluster& cluster) {
  const auto row_optional = cluster
                                .Execute(ClusterHostType::kPrimary,
                                         "SELECT id, value FROM SampleTable")
                                .AsOptionalSingleRow<SampleRow>();
 
  static_assert(
      std::is_same_v<const std::optional<SampleRow>, decltype(row_optional)>);
  EXPECT_FALSE(row_optional.has_value());
}

Definition at line 316 of file statement_result_set.hpp.

AsSingleField()

template<typename T >

T storages::mysql::StatementResultSet::AsSingleField

(

)

&&

Parse statement result as T. Result set is expected to have a single row and a single column, T is expected to be one of supported types. See MySQL supported types for supported types.

UINVARIANTs on columns count not being equal to 1 or type mismatch. throws if result set is empty of contains more than one row.

void PerformAsSingleField(const Cluster& cluster) {
  cluster.Execute(ClusterHostType::kPrimary,
                  "INSERT INTO SampleTable(id, value) VALUES (?, ?)",  //
                  1, "some value");
 
  const auto value =
      cluster
          .Execute(ClusterHostType::kPrimary, "SELECT value FROM SampleTable")
          .AsSingleField<std::string>();
  EXPECT_EQ(value, "some value");
}

Definition at line 305 of file statement_result_set.hpp.

AsSingleRow()

template<typename T >

T storages::mysql::StatementResultSet::AsSingleRow

(

)

&&

Parse statement result as T. Result set is expected to have a single row, T is expected to be an aggregate of supported types. See MySQL supported types for better understanding of T requirements.

UINVARIANTs on columns count mismatch or types mismatch. throws if result set is empty or contains more than one row.

struct SampleRow final {
  std::int32_t id;
  std::string value;
 
  bool operator==(const SampleRow& other) const {
    return id == other.id && value == other.value;
  }
};
 
void PerformAsSingleRow(const Cluster& cluster, const SampleRow& data) {
  cluster.ExecuteDecompose(ClusterHostType::kPrimary,
                           "INSERT INTO SampleTable(id, value) VALUES (?, ?)",
                           data);
 
  const auto db_row = cluster
                          .Execute(ClusterHostType::kPrimary,
                                   "SELECT id, value FROM SampleTable")
                          .AsSingleRow<SampleRow>();
  EXPECT_EQ(data, db_row);
}

Definition at line 294 of file statement_result_set.hpp.

AsVector() [1/2]

template<typename T >

std::vector< T > storages::mysql::StatementResultSet::AsVector

(

)

&&

Parse statement result set as std::vector<T>. T is expected to be an aggregate of supported types. See MySQL supported types for better understanding of T requirements.

UINVARIANTs on columns count mismatch or types mismatch.

struct SampleRow final {
  std::int32_t id;
  std::string value;
 
  bool operator==(const SampleRow& other) const {
    return id == other.id && value == other.value;
  }
};
 
void PerformAsVector(const Cluster& cluster,
                     const std::vector<SampleRow>& expected_data) {
  cluster.ExecuteBulk(ClusterHostType::kPrimary,
                      "INSERT INTO SampleTable(id, value) VALUES (?, ?)",
                      expected_data);
 
  const auto db_rows = cluster
                           .Execute(ClusterHostType::kPrimary,
                                    "SELECT id, value FROM SampleTable")
                           .AsVector<SampleRow>();
 
  static_assert(
      std::is_same_v<const std::vector<SampleRow>, decltype(db_rows)>);
  EXPECT_EQ(expected_data, db_rows);
}

Definition at line 266 of file statement_result_set.hpp.

AsVector() [2/2]

template<typename T >

std::vector< T > storages::mysql::StatementResultSet::AsVector

(

FieldTag

)

&&

Parse statement result set as std::vector<T>. Result set is expected to have a single column, T is expected to be one of supported types. See MySQL supported types for supported typed.

UINVARIANTs on columns count not being equal to 1 or type mismatch.

void PerformAsVectorFieldTag(const Cluster& cluster) {
  const auto vector_of_field_values =
      cluster
          .Execute(ClusterHostType::kPrimary, "SELECT value FROM SampleTable")
          .AsVector<std::string>(kFieldTag);
 
  static_assert(std::is_same_v<const std::vector<std::string>,
                               decltype(vector_of_field_values)>);
}

Definition at line 271 of file statement_result_set.hpp.

MapFrom()

template<typename DbType >

MappedStatementResultSet< DbType > storages::mysql::StatementResultSet::MapFrom

(

)

&&

Converts to an interface for on-the-flight mapping statement result set from DbType. DbType is expected to be an aggregate of supported types. See MySQL supported types for better understanding of DbType requirements.

struct SampleRow final {
  std::int32_t id;
  std::string value;
 
  bool operator==(const SampleRow& other) const {
    return id == other.id && value == other.value;
  }
};
 
std::pair<const std::int32_t, std::string> Convert(
    SampleRow&& db_row,
    storages::mysql::convert::To<std::pair<const std::int32_t, std::string>>) {
  return {db_row.id, std::move(db_row.value)};
}
 
void PerformMapFrom(const Cluster& cluster,
                    const std::vector<SampleRow>& data) {
  cluster.ExecuteBulk(ClusterHostType::kPrimary,
                      "INSERT INTO SampleTable(id, value) VALUES(?, ?)", data);
 
  const auto id_value_map =
      cluster
          .Execute(ClusterHostType::kPrimary,
                   "SELECT id, value FROM SampleTable")
          .MapFrom<SampleRow>()
          .AsContainer<std::unordered_map<std::int32_t, std::string>>();
 
  static_assert(
      std::is_same_v<const std::unordered_map<std::int32_t, std::string>,
                     decltype(id_value_map)>);
  EXPECT_EQ(id_value_map.size(), data.size());
  for (const auto& [k, v] : data) {
    ASSERT_EQ(id_value_map.at(k), v);
  }
}

Definition at line 397 of file statement_result_set.hpp.

Friends And Related Symbol Documentation

CursorResultSet

template<typename T >

friend class CursorResultSet

friend

Definition at line 177 of file statement_result_set.hpp.

MappedStatementResultSet

template<typename DbType >

friend class MappedStatementResultSet

friend

Definition at line 180 of file statement_result_set.hpp.

---

The documentation for this class was generated from the following file:

• userver/storages/mysql/statement_result_set.hpp