QueryExecution.h

 
#pragma once
#include <aws/athena/Athena_EXPORTS.h>
#include <aws/athena/model/EngineVersion.h>
#include <aws/athena/model/ManagedQueryResultsConfiguration.h>
#include <aws/athena/model/QueryExecutionContext.h>
#include <aws/athena/model/QueryExecutionStatistics.h>
#include <aws/athena/model/QueryExecutionStatus.h>
#include <aws/athena/model/QueryResultsS3AccessGrantsConfiguration.h>
#include <aws/athena/model/ResultConfiguration.h>
#include <aws/athena/model/ResultReuseConfiguration.h>
#include <aws/athena/model/StatementType.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Athena {
namespace Model {
 
class QueryExecution {
 public:
  AWS_ATHENA_API QueryExecution() = default;
  AWS_ATHENA_API QueryExecution(Aws::Utils::Json::JsonView jsonValue);
  AWS_ATHENA_API QueryExecution& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_ATHENA_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetQueryExecutionId() const { return m_queryExecutionId; }
  inline bool QueryExecutionIdHasBeenSet() const { return m_queryExecutionIdHasBeenSet; }
  template <typename QueryExecutionIdT = Aws::String>
  void SetQueryExecutionId(QueryExecutionIdT&& value) {
    m_queryExecutionIdHasBeenSet = true;
    m_queryExecutionId = std::forward<QueryExecutionIdT>(value);
  }
  template <typename QueryExecutionIdT = Aws::String>
  QueryExecution& WithQueryExecutionId(QueryExecutionIdT&& value) {
    SetQueryExecutionId(std::forward<QueryExecutionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetQuery() const { return m_query; }
  inline bool QueryHasBeenSet() const { return m_queryHasBeenSet; }
  template <typename QueryT = Aws::String>
  void SetQuery(QueryT&& value) {
    m_queryHasBeenSet = true;
    m_query = std::forward<QueryT>(value);
  }
  template <typename QueryT = Aws::String>
  QueryExecution& WithQuery(QueryT&& value) {
    SetQuery(std::forward<QueryT>(value));
    return *this;
  }
 
 
  inline StatementType GetStatementType() const { return m_statementType; }
  inline bool StatementTypeHasBeenSet() const { return m_statementTypeHasBeenSet; }
  inline void SetStatementType(StatementType value) {
    m_statementTypeHasBeenSet = true;
    m_statementType = value;
  }
  inline QueryExecution& WithStatementType(StatementType value) {
    SetStatementType(value);
    return *this;
  }
 
 
  inline const ManagedQueryResultsConfiguration& GetManagedQueryResultsConfiguration() const { return m_managedQueryResultsConfiguration; }
  inline bool ManagedQueryResultsConfigurationHasBeenSet() const { return m_managedQueryResultsConfigurationHasBeenSet; }
  template <typename ManagedQueryResultsConfigurationT = ManagedQueryResultsConfiguration>
  void SetManagedQueryResultsConfiguration(ManagedQueryResultsConfigurationT&& value) {
    m_managedQueryResultsConfigurationHasBeenSet = true;
    m_managedQueryResultsConfiguration = std::forward<ManagedQueryResultsConfigurationT>(value);
  }
  template <typename ManagedQueryResultsConfigurationT = ManagedQueryResultsConfiguration>
  QueryExecution& WithManagedQueryResultsConfiguration(ManagedQueryResultsConfigurationT&& value) {
    SetManagedQueryResultsConfiguration(std::forward<ManagedQueryResultsConfigurationT>(value));
    return *this;
  }
 
 
  inline const ResultConfiguration& GetResultConfiguration() const { return m_resultConfiguration; }
  inline bool ResultConfigurationHasBeenSet() const { return m_resultConfigurationHasBeenSet; }
  template <typename ResultConfigurationT = ResultConfiguration>
  void SetResultConfiguration(ResultConfigurationT&& value) {
    m_resultConfigurationHasBeenSet = true;
    m_resultConfiguration = std::forward<ResultConfigurationT>(value);
  }
  template <typename ResultConfigurationT = ResultConfiguration>
  QueryExecution& WithResultConfiguration(ResultConfigurationT&& value) {
    SetResultConfiguration(std::forward<ResultConfigurationT>(value));
    return *this;
  }
 
 
  inline const ResultReuseConfiguration& GetResultReuseConfiguration() const { return m_resultReuseConfiguration; }
  inline bool ResultReuseConfigurationHasBeenSet() const { return m_resultReuseConfigurationHasBeenSet; }
  template <typename ResultReuseConfigurationT = ResultReuseConfiguration>
  void SetResultReuseConfiguration(ResultReuseConfigurationT&& value) {
    m_resultReuseConfigurationHasBeenSet = true;
    m_resultReuseConfiguration = std::forward<ResultReuseConfigurationT>(value);
  }
  template <typename ResultReuseConfigurationT = ResultReuseConfiguration>
  QueryExecution& WithResultReuseConfiguration(ResultReuseConfigurationT&& value) {
    SetResultReuseConfiguration(std::forward<ResultReuseConfigurationT>(value));
    return *this;
  }
 
 
  inline const QueryExecutionContext& GetQueryExecutionContext() const { return m_queryExecutionContext; }
  inline bool QueryExecutionContextHasBeenSet() const { return m_queryExecutionContextHasBeenSet; }
  template <typename QueryExecutionContextT = QueryExecutionContext>
  void SetQueryExecutionContext(QueryExecutionContextT&& value) {
    m_queryExecutionContextHasBeenSet = true;
    m_queryExecutionContext = std::forward<QueryExecutionContextT>(value);
  }
  template <typename QueryExecutionContextT = QueryExecutionContext>
  QueryExecution& WithQueryExecutionContext(QueryExecutionContextT&& value) {
    SetQueryExecutionContext(std::forward<QueryExecutionContextT>(value));
    return *this;
  }
 
 
  inline const QueryExecutionStatus& GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  template <typename StatusT = QueryExecutionStatus>
  void SetStatus(StatusT&& value) {
    m_statusHasBeenSet = true;
    m_status = std::forward<StatusT>(value);
  }
  template <typename StatusT = QueryExecutionStatus>
  QueryExecution& WithStatus(StatusT&& value) {
    SetStatus(std::forward<StatusT>(value));
    return *this;
  }
 
 
  inline const QueryExecutionStatistics& GetStatistics() const { return m_statistics; }
  inline bool StatisticsHasBeenSet() const { return m_statisticsHasBeenSet; }
  template <typename StatisticsT = QueryExecutionStatistics>
  void SetStatistics(StatisticsT&& value) {
    m_statisticsHasBeenSet = true;
    m_statistics = std::forward<StatisticsT>(value);
  }
  template <typename StatisticsT = QueryExecutionStatistics>
  QueryExecution& WithStatistics(StatisticsT&& value) {
    SetStatistics(std::forward<StatisticsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetWorkGroup() const { return m_workGroup; }
  inline bool WorkGroupHasBeenSet() const { return m_workGroupHasBeenSet; }
  template <typename WorkGroupT = Aws::String>
  void SetWorkGroup(WorkGroupT&& value) {
    m_workGroupHasBeenSet = true;
    m_workGroup = std::forward<WorkGroupT>(value);
  }
  template <typename WorkGroupT = Aws::String>
  QueryExecution& WithWorkGroup(WorkGroupT&& value) {
    SetWorkGroup(std::forward<WorkGroupT>(value));
    return *this;
  }
 
 
  inline const EngineVersion& GetEngineVersion() const { return m_engineVersion; }
  inline bool EngineVersionHasBeenSet() const { return m_engineVersionHasBeenSet; }
  template <typename EngineVersionT = EngineVersion>
  void SetEngineVersion(EngineVersionT&& value) {
    m_engineVersionHasBeenSet = true;
    m_engineVersion = std::forward<EngineVersionT>(value);
  }
  template <typename EngineVersionT = EngineVersion>
  QueryExecution& WithEngineVersion(EngineVersionT&& value) {
    SetEngineVersion(std::forward<EngineVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetExecutionParameters() const { return m_executionParameters; }
  inline bool ExecutionParametersHasBeenSet() const { return m_executionParametersHasBeenSet; }
  template <typename ExecutionParametersT = Aws::Vector<Aws::String>>
  void SetExecutionParameters(ExecutionParametersT&& value) {
    m_executionParametersHasBeenSet = true;
    m_executionParameters = std::forward<ExecutionParametersT>(value);
  }
  template <typename ExecutionParametersT = Aws::Vector<Aws::String>>
  QueryExecution& WithExecutionParameters(ExecutionParametersT&& value) {
    SetExecutionParameters(std::forward<ExecutionParametersT>(value));
    return *this;
  }
  template <typename ExecutionParametersT = Aws::String>
  QueryExecution& AddExecutionParameters(ExecutionParametersT&& value) {
    m_executionParametersHasBeenSet = true;
    m_executionParameters.emplace_back(std::forward<ExecutionParametersT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSubstatementType() const { return m_substatementType; }
  inline bool SubstatementTypeHasBeenSet() const { return m_substatementTypeHasBeenSet; }
  template <typename SubstatementTypeT = Aws::String>
  void SetSubstatementType(SubstatementTypeT&& value) {
    m_substatementTypeHasBeenSet = true;
    m_substatementType = std::forward<SubstatementTypeT>(value);
  }
  template <typename SubstatementTypeT = Aws::String>
  QueryExecution& WithSubstatementType(SubstatementTypeT&& value) {
    SetSubstatementType(std::forward<SubstatementTypeT>(value));
    return *this;
  }
 
 
  inline const QueryResultsS3AccessGrantsConfiguration& GetQueryResultsS3AccessGrantsConfiguration() const {
    return m_queryResultsS3AccessGrantsConfiguration;
  }
  inline bool QueryResultsS3AccessGrantsConfigurationHasBeenSet() const { return m_queryResultsS3AccessGrantsConfigurationHasBeenSet; }
  template <typename QueryResultsS3AccessGrantsConfigurationT = QueryResultsS3AccessGrantsConfiguration>
  void SetQueryResultsS3AccessGrantsConfiguration(QueryResultsS3AccessGrantsConfigurationT&& value) {
    m_queryResultsS3AccessGrantsConfigurationHasBeenSet = true;
    m_queryResultsS3AccessGrantsConfiguration = std::forward<QueryResultsS3AccessGrantsConfigurationT>(value);
  }
  template <typename QueryResultsS3AccessGrantsConfigurationT = QueryResultsS3AccessGrantsConfiguration>
  QueryExecution& WithQueryResultsS3AccessGrantsConfiguration(QueryResultsS3AccessGrantsConfigurationT&& value) {
    SetQueryResultsS3AccessGrantsConfiguration(std::forward<QueryResultsS3AccessGrantsConfigurationT>(value));
    return *this;
  }
 private:
  Aws::String m_queryExecutionId;
 
  Aws::String m_query;
 
  StatementType m_statementType{StatementType::NOT_SET};
 
  ManagedQueryResultsConfiguration m_managedQueryResultsConfiguration;
 
  ResultConfiguration m_resultConfiguration;
 
  ResultReuseConfiguration m_resultReuseConfiguration;
 
  QueryExecutionContext m_queryExecutionContext;
 
  QueryExecutionStatus m_status;
 
  QueryExecutionStatistics m_statistics;
 
  Aws::String m_workGroup;
 
  EngineVersion m_engineVersion;
 
  Aws::Vector<Aws::String> m_executionParameters;
 
  Aws::String m_substatementType;
 
  QueryResultsS3AccessGrantsConfiguration m_queryResultsS3AccessGrantsConfiguration;
  bool m_queryExecutionIdHasBeenSet = false;
  bool m_queryHasBeenSet = false;
  bool m_statementTypeHasBeenSet = false;
  bool m_managedQueryResultsConfigurationHasBeenSet = false;
  bool m_resultConfigurationHasBeenSet = false;
  bool m_resultReuseConfigurationHasBeenSet = false;
  bool m_queryExecutionContextHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_statisticsHasBeenSet = false;
  bool m_workGroupHasBeenSet = false;
  bool m_engineVersionHasBeenSet = false;
  bool m_executionParametersHasBeenSet = false;
  bool m_substatementTypeHasBeenSet = false;
  bool m_queryResultsS3AccessGrantsConfigurationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Athena
}  // namespace Aws