RedshiftDataSpec.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/machinelearning/MachineLearning_EXPORTS.h>
#include <aws/machinelearning/model/RedshiftDatabase.h>
#include <aws/machinelearning/model/RedshiftDatabaseCredentials.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MachineLearning {
namespace Model {
 
class RedshiftDataSpec {
 public:
  AWS_MACHINELEARNING_API RedshiftDataSpec() = default;
  AWS_MACHINELEARNING_API RedshiftDataSpec(Aws::Utils::Json::JsonView jsonValue);
  AWS_MACHINELEARNING_API RedshiftDataSpec& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MACHINELEARNING_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const RedshiftDatabase& GetDatabaseInformation() const { return m_databaseInformation; }
  inline bool DatabaseInformationHasBeenSet() const { return m_databaseInformationHasBeenSet; }
  template <typename DatabaseInformationT = RedshiftDatabase>
  void SetDatabaseInformation(DatabaseInformationT&& value) {
    m_databaseInformationHasBeenSet = true;
    m_databaseInformation = std::forward<DatabaseInformationT>(value);
  }
  template <typename DatabaseInformationT = RedshiftDatabase>
  RedshiftDataSpec& WithDatabaseInformation(DatabaseInformationT&& value) {
    SetDatabaseInformation(std::forward<DatabaseInformationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSelectSqlQuery() const { return m_selectSqlQuery; }
  inline bool SelectSqlQueryHasBeenSet() const { return m_selectSqlQueryHasBeenSet; }
  template <typename SelectSqlQueryT = Aws::String>
  void SetSelectSqlQuery(SelectSqlQueryT&& value) {
    m_selectSqlQueryHasBeenSet = true;
    m_selectSqlQuery = std::forward<SelectSqlQueryT>(value);
  }
  template <typename SelectSqlQueryT = Aws::String>
  RedshiftDataSpec& WithSelectSqlQuery(SelectSqlQueryT&& value) {
    SetSelectSqlQuery(std::forward<SelectSqlQueryT>(value));
    return *this;
  }
 
 
  inline const RedshiftDatabaseCredentials& GetDatabaseCredentials() const { return m_databaseCredentials; }
  inline bool DatabaseCredentialsHasBeenSet() const { return m_databaseCredentialsHasBeenSet; }
  template <typename DatabaseCredentialsT = RedshiftDatabaseCredentials>
  void SetDatabaseCredentials(DatabaseCredentialsT&& value) {
    m_databaseCredentialsHasBeenSet = true;
    m_databaseCredentials = std::forward<DatabaseCredentialsT>(value);
  }
  template <typename DatabaseCredentialsT = RedshiftDatabaseCredentials>
  RedshiftDataSpec& WithDatabaseCredentials(DatabaseCredentialsT&& value) {
    SetDatabaseCredentials(std::forward<DatabaseCredentialsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetS3StagingLocation() const { return m_s3StagingLocation; }
  inline bool S3StagingLocationHasBeenSet() const { return m_s3StagingLocationHasBeenSet; }
  template <typename S3StagingLocationT = Aws::String>
  void SetS3StagingLocation(S3StagingLocationT&& value) {
    m_s3StagingLocationHasBeenSet = true;
    m_s3StagingLocation = std::forward<S3StagingLocationT>(value);
  }
  template <typename S3StagingLocationT = Aws::String>
  RedshiftDataSpec& WithS3StagingLocation(S3StagingLocationT&& value) {
    SetS3StagingLocation(std::forward<S3StagingLocationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDataRearrangement() const { return m_dataRearrangement; }
  inline bool DataRearrangementHasBeenSet() const { return m_dataRearrangementHasBeenSet; }
  template <typename DataRearrangementT = Aws::String>
  void SetDataRearrangement(DataRearrangementT&& value) {
    m_dataRearrangementHasBeenSet = true;
    m_dataRearrangement = std::forward<DataRearrangementT>(value);
  }
  template <typename DataRearrangementT = Aws::String>
  RedshiftDataSpec& WithDataRearrangement(DataRearrangementT&& value) {
    SetDataRearrangement(std::forward<DataRearrangementT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDataSchema() const { return m_dataSchema; }
  inline bool DataSchemaHasBeenSet() const { return m_dataSchemaHasBeenSet; }
  template <typename DataSchemaT = Aws::String>
  void SetDataSchema(DataSchemaT&& value) {
    m_dataSchemaHasBeenSet = true;
    m_dataSchema = std::forward<DataSchemaT>(value);
  }
  template <typename DataSchemaT = Aws::String>
  RedshiftDataSpec& WithDataSchema(DataSchemaT&& value) {
    SetDataSchema(std::forward<DataSchemaT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDataSchemaUri() const { return m_dataSchemaUri; }
  inline bool DataSchemaUriHasBeenSet() const { return m_dataSchemaUriHasBeenSet; }
  template <typename DataSchemaUriT = Aws::String>
  void SetDataSchemaUri(DataSchemaUriT&& value) {
    m_dataSchemaUriHasBeenSet = true;
    m_dataSchemaUri = std::forward<DataSchemaUriT>(value);
  }
  template <typename DataSchemaUriT = Aws::String>
  RedshiftDataSpec& WithDataSchemaUri(DataSchemaUriT&& value) {
    SetDataSchemaUri(std::forward<DataSchemaUriT>(value));
    return *this;
  }
 private:
  RedshiftDatabase m_databaseInformation;
 
  Aws::String m_selectSqlQuery;
 
  RedshiftDatabaseCredentials m_databaseCredentials;
 
  Aws::String m_s3StagingLocation;
 
  Aws::String m_dataRearrangement;
 
  Aws::String m_dataSchema;
 
  Aws::String m_dataSchemaUri;
  bool m_databaseInformationHasBeenSet = false;
  bool m_selectSqlQueryHasBeenSet = false;
  bool m_databaseCredentialsHasBeenSet = false;
  bool m_s3StagingLocationHasBeenSet = false;
  bool m_dataRearrangementHasBeenSet = false;
  bool m_dataSchemaHasBeenSet = false;
  bool m_dataSchemaUriHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MachineLearning
}  // namespace Aws