ColumnStatisticsTaskSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/glue/model/ExecutionAttempt.h>
#include <aws/glue/model/Schedule.h>
#include <aws/glue/model/ScheduleType.h>
#include <aws/glue/model/SettingSource.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Glue {
namespace Model {
 
class ColumnStatisticsTaskSettings {
 public:
  AWS_GLUE_API ColumnStatisticsTaskSettings() = default;
  AWS_GLUE_API ColumnStatisticsTaskSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API ColumnStatisticsTaskSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetDatabaseName() const { return m_databaseName; }
  inline bool DatabaseNameHasBeenSet() const { return m_databaseNameHasBeenSet; }
  template <typename DatabaseNameT = Aws::String>
  void SetDatabaseName(DatabaseNameT&& value) {
    m_databaseNameHasBeenSet = true;
    m_databaseName = std::forward<DatabaseNameT>(value);
  }
  template <typename DatabaseNameT = Aws::String>
  ColumnStatisticsTaskSettings& WithDatabaseName(DatabaseNameT&& value) {
    SetDatabaseName(std::forward<DatabaseNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTableName() const { return m_tableName; }
  inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
  template <typename TableNameT = Aws::String>
  void SetTableName(TableNameT&& value) {
    m_tableNameHasBeenSet = true;
    m_tableName = std::forward<TableNameT>(value);
  }
  template <typename TableNameT = Aws::String>
  ColumnStatisticsTaskSettings& WithTableName(TableNameT&& value) {
    SetTableName(std::forward<TableNameT>(value));
    return *this;
  }
 
 
  inline const Schedule& GetSchedule() const { return m_schedule; }
  inline bool ScheduleHasBeenSet() const { return m_scheduleHasBeenSet; }
  template <typename ScheduleT = Schedule>
  void SetSchedule(ScheduleT&& value) {
    m_scheduleHasBeenSet = true;
    m_schedule = std::forward<ScheduleT>(value);
  }
  template <typename ScheduleT = Schedule>
  ColumnStatisticsTaskSettings& WithSchedule(ScheduleT&& value) {
    SetSchedule(std::forward<ScheduleT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetColumnNameList() const { return m_columnNameList; }
  inline bool ColumnNameListHasBeenSet() const { return m_columnNameListHasBeenSet; }
  template <typename ColumnNameListT = Aws::Vector<Aws::String>>
  void SetColumnNameList(ColumnNameListT&& value) {
    m_columnNameListHasBeenSet = true;
    m_columnNameList = std::forward<ColumnNameListT>(value);
  }
  template <typename ColumnNameListT = Aws::Vector<Aws::String>>
  ColumnStatisticsTaskSettings& WithColumnNameList(ColumnNameListT&& value) {
    SetColumnNameList(std::forward<ColumnNameListT>(value));
    return *this;
  }
  template <typename ColumnNameListT = Aws::String>
  ColumnStatisticsTaskSettings& AddColumnNameList(ColumnNameListT&& value) {
    m_columnNameListHasBeenSet = true;
    m_columnNameList.emplace_back(std::forward<ColumnNameListT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCatalogID() const { return m_catalogID; }
  inline bool CatalogIDHasBeenSet() const { return m_catalogIDHasBeenSet; }
  template <typename CatalogIDT = Aws::String>
  void SetCatalogID(CatalogIDT&& value) {
    m_catalogIDHasBeenSet = true;
    m_catalogID = std::forward<CatalogIDT>(value);
  }
  template <typename CatalogIDT = Aws::String>
  ColumnStatisticsTaskSettings& WithCatalogID(CatalogIDT&& value) {
    SetCatalogID(std::forward<CatalogIDT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRole() const { return m_role; }
  inline bool RoleHasBeenSet() const { return m_roleHasBeenSet; }
  template <typename RoleT = Aws::String>
  void SetRole(RoleT&& value) {
    m_roleHasBeenSet = true;
    m_role = std::forward<RoleT>(value);
  }
  template <typename RoleT = Aws::String>
  ColumnStatisticsTaskSettings& WithRole(RoleT&& value) {
    SetRole(std::forward<RoleT>(value));
    return *this;
  }
 
 
  inline double GetSampleSize() const { return m_sampleSize; }
  inline bool SampleSizeHasBeenSet() const { return m_sampleSizeHasBeenSet; }
  inline void SetSampleSize(double value) {
    m_sampleSizeHasBeenSet = true;
    m_sampleSize = value;
  }
  inline ColumnStatisticsTaskSettings& WithSampleSize(double value) {
    SetSampleSize(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSecurityConfiguration() const { return m_securityConfiguration; }
  inline bool SecurityConfigurationHasBeenSet() const { return m_securityConfigurationHasBeenSet; }
  template <typename SecurityConfigurationT = Aws::String>
  void SetSecurityConfiguration(SecurityConfigurationT&& value) {
    m_securityConfigurationHasBeenSet = true;
    m_securityConfiguration = std::forward<SecurityConfigurationT>(value);
  }
  template <typename SecurityConfigurationT = Aws::String>
  ColumnStatisticsTaskSettings& WithSecurityConfiguration(SecurityConfigurationT&& value) {
    SetSecurityConfiguration(std::forward<SecurityConfigurationT>(value));
    return *this;
  }
 
 
  inline ScheduleType GetScheduleType() const { return m_scheduleType; }
  inline bool ScheduleTypeHasBeenSet() const { return m_scheduleTypeHasBeenSet; }
  inline void SetScheduleType(ScheduleType value) {
    m_scheduleTypeHasBeenSet = true;
    m_scheduleType = value;
  }
  inline ColumnStatisticsTaskSettings& WithScheduleType(ScheduleType value) {
    SetScheduleType(value);
    return *this;
  }
 
 
  inline SettingSource GetSettingSource() const { return m_settingSource; }
  inline bool SettingSourceHasBeenSet() const { return m_settingSourceHasBeenSet; }
  inline void SetSettingSource(SettingSource value) {
    m_settingSourceHasBeenSet = true;
    m_settingSource = value;
  }
  inline ColumnStatisticsTaskSettings& WithSettingSource(SettingSource value) {
    SetSettingSource(value);
    return *this;
  }
 
 
  inline const ExecutionAttempt& GetLastExecutionAttempt() const { return m_lastExecutionAttempt; }
  inline bool LastExecutionAttemptHasBeenSet() const { return m_lastExecutionAttemptHasBeenSet; }
  template <typename LastExecutionAttemptT = ExecutionAttempt>
  void SetLastExecutionAttempt(LastExecutionAttemptT&& value) {
    m_lastExecutionAttemptHasBeenSet = true;
    m_lastExecutionAttempt = std::forward<LastExecutionAttemptT>(value);
  }
  template <typename LastExecutionAttemptT = ExecutionAttempt>
  ColumnStatisticsTaskSettings& WithLastExecutionAttempt(LastExecutionAttemptT&& value) {
    SetLastExecutionAttempt(std::forward<LastExecutionAttemptT>(value));
    return *this;
  }
 private:
  Aws::String m_databaseName;
 
  Aws::String m_tableName;
 
  Schedule m_schedule;
 
  Aws::Vector<Aws::String> m_columnNameList;
 
  Aws::String m_catalogID;
 
  Aws::String m_role;
 
  double m_sampleSize{0.0};
 
  Aws::String m_securityConfiguration;
 
  ScheduleType m_scheduleType{ScheduleType::NOT_SET};
 
  SettingSource m_settingSource{SettingSource::NOT_SET};
 
  ExecutionAttempt m_lastExecutionAttempt;
  bool m_databaseNameHasBeenSet = false;
  bool m_tableNameHasBeenSet = false;
  bool m_scheduleHasBeenSet = false;
  bool m_columnNameListHasBeenSet = false;
  bool m_catalogIDHasBeenSet = false;
  bool m_roleHasBeenSet = false;
  bool m_sampleSizeHasBeenSet = false;
  bool m_securityConfigurationHasBeenSet = false;
  bool m_scheduleTypeHasBeenSet = false;
  bool m_settingSourceHasBeenSet = false;
  bool m_lastExecutionAttemptHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Glue
}  // namespace Aws