TableStatistics.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/dms/DatabaseMigrationService_EXPORTS.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DatabaseMigrationService {
namespace Model {
 
class TableStatistics {
 public:
  AWS_DATABASEMIGRATIONSERVICE_API TableStatistics() = default;
  AWS_DATABASEMIGRATIONSERVICE_API TableStatistics(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATABASEMIGRATIONSERVICE_API TableStatistics& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATABASEMIGRATIONSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetSchemaName() const { return m_schemaName; }
  inline bool SchemaNameHasBeenSet() const { return m_schemaNameHasBeenSet; }
  template <typename SchemaNameT = Aws::String>
  void SetSchemaName(SchemaNameT&& value) {
    m_schemaNameHasBeenSet = true;
    m_schemaName = std::forward<SchemaNameT>(value);
  }
  template <typename SchemaNameT = Aws::String>
  TableStatistics& WithSchemaName(SchemaNameT&& value) {
    SetSchemaName(std::forward<SchemaNameT>(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>
  TableStatistics& WithTableName(TableNameT&& value) {
    SetTableName(std::forward<TableNameT>(value));
    return *this;
  }
 
 
  inline long long GetInserts() const { return m_inserts; }
  inline bool InsertsHasBeenSet() const { return m_insertsHasBeenSet; }
  inline void SetInserts(long long value) {
    m_insertsHasBeenSet = true;
    m_inserts = value;
  }
  inline TableStatistics& WithInserts(long long value) {
    SetInserts(value);
    return *this;
  }
 
 
  inline long long GetDeletes() const { return m_deletes; }
  inline bool DeletesHasBeenSet() const { return m_deletesHasBeenSet; }
  inline void SetDeletes(long long value) {
    m_deletesHasBeenSet = true;
    m_deletes = value;
  }
  inline TableStatistics& WithDeletes(long long value) {
    SetDeletes(value);
    return *this;
  }
 
 
  inline long long GetUpdates() const { return m_updates; }
  inline bool UpdatesHasBeenSet() const { return m_updatesHasBeenSet; }
  inline void SetUpdates(long long value) {
    m_updatesHasBeenSet = true;
    m_updates = value;
  }
  inline TableStatistics& WithUpdates(long long value) {
    SetUpdates(value);
    return *this;
  }
 
 
  inline long long GetDdls() const { return m_ddls; }
  inline bool DdlsHasBeenSet() const { return m_ddlsHasBeenSet; }
  inline void SetDdls(long long value) {
    m_ddlsHasBeenSet = true;
    m_ddls = value;
  }
  inline TableStatistics& WithDdls(long long value) {
    SetDdls(value);
    return *this;
  }
 
 
  inline long long GetAppliedInserts() const { return m_appliedInserts; }
  inline bool AppliedInsertsHasBeenSet() const { return m_appliedInsertsHasBeenSet; }
  inline void SetAppliedInserts(long long value) {
    m_appliedInsertsHasBeenSet = true;
    m_appliedInserts = value;
  }
  inline TableStatistics& WithAppliedInserts(long long value) {
    SetAppliedInserts(value);
    return *this;
  }
 
 
  inline long long GetAppliedDeletes() const { return m_appliedDeletes; }
  inline bool AppliedDeletesHasBeenSet() const { return m_appliedDeletesHasBeenSet; }
  inline void SetAppliedDeletes(long long value) {
    m_appliedDeletesHasBeenSet = true;
    m_appliedDeletes = value;
  }
  inline TableStatistics& WithAppliedDeletes(long long value) {
    SetAppliedDeletes(value);
    return *this;
  }
 
 
  inline long long GetAppliedUpdates() const { return m_appliedUpdates; }
  inline bool AppliedUpdatesHasBeenSet() const { return m_appliedUpdatesHasBeenSet; }
  inline void SetAppliedUpdates(long long value) {
    m_appliedUpdatesHasBeenSet = true;
    m_appliedUpdates = value;
  }
  inline TableStatistics& WithAppliedUpdates(long long value) {
    SetAppliedUpdates(value);
    return *this;
  }
 
 
  inline long long GetAppliedDdls() const { return m_appliedDdls; }
  inline bool AppliedDdlsHasBeenSet() const { return m_appliedDdlsHasBeenSet; }
  inline void SetAppliedDdls(long long value) {
    m_appliedDdlsHasBeenSet = true;
    m_appliedDdls = value;
  }
  inline TableStatistics& WithAppliedDdls(long long value) {
    SetAppliedDdls(value);
    return *this;
  }
 
 
  inline long long GetFullLoadRows() const { return m_fullLoadRows; }
  inline bool FullLoadRowsHasBeenSet() const { return m_fullLoadRowsHasBeenSet; }
  inline void SetFullLoadRows(long long value) {
    m_fullLoadRowsHasBeenSet = true;
    m_fullLoadRows = value;
  }
  inline TableStatistics& WithFullLoadRows(long long value) {
    SetFullLoadRows(value);
    return *this;
  }
 
 
  inline long long GetFullLoadCondtnlChkFailedRows() const { return m_fullLoadCondtnlChkFailedRows; }
  inline bool FullLoadCondtnlChkFailedRowsHasBeenSet() const { return m_fullLoadCondtnlChkFailedRowsHasBeenSet; }
  inline void SetFullLoadCondtnlChkFailedRows(long long value) {
    m_fullLoadCondtnlChkFailedRowsHasBeenSet = true;
    m_fullLoadCondtnlChkFailedRows = value;
  }
  inline TableStatistics& WithFullLoadCondtnlChkFailedRows(long long value) {
    SetFullLoadCondtnlChkFailedRows(value);
    return *this;
  }
 
 
  inline long long GetFullLoadErrorRows() const { return m_fullLoadErrorRows; }
  inline bool FullLoadErrorRowsHasBeenSet() const { return m_fullLoadErrorRowsHasBeenSet; }
  inline void SetFullLoadErrorRows(long long value) {
    m_fullLoadErrorRowsHasBeenSet = true;
    m_fullLoadErrorRows = value;
  }
  inline TableStatistics& WithFullLoadErrorRows(long long value) {
    SetFullLoadErrorRows(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetFullLoadStartTime() const { return m_fullLoadStartTime; }
  inline bool FullLoadStartTimeHasBeenSet() const { return m_fullLoadStartTimeHasBeenSet; }
  template <typename FullLoadStartTimeT = Aws::Utils::DateTime>
  void SetFullLoadStartTime(FullLoadStartTimeT&& value) {
    m_fullLoadStartTimeHasBeenSet = true;
    m_fullLoadStartTime = std::forward<FullLoadStartTimeT>(value);
  }
  template <typename FullLoadStartTimeT = Aws::Utils::DateTime>
  TableStatistics& WithFullLoadStartTime(FullLoadStartTimeT&& value) {
    SetFullLoadStartTime(std::forward<FullLoadStartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetFullLoadEndTime() const { return m_fullLoadEndTime; }
  inline bool FullLoadEndTimeHasBeenSet() const { return m_fullLoadEndTimeHasBeenSet; }
  template <typename FullLoadEndTimeT = Aws::Utils::DateTime>
  void SetFullLoadEndTime(FullLoadEndTimeT&& value) {
    m_fullLoadEndTimeHasBeenSet = true;
    m_fullLoadEndTime = std::forward<FullLoadEndTimeT>(value);
  }
  template <typename FullLoadEndTimeT = Aws::Utils::DateTime>
  TableStatistics& WithFullLoadEndTime(FullLoadEndTimeT&& value) {
    SetFullLoadEndTime(std::forward<FullLoadEndTimeT>(value));
    return *this;
  }
 
 
  inline bool GetFullLoadReloaded() const { return m_fullLoadReloaded; }
  inline bool FullLoadReloadedHasBeenSet() const { return m_fullLoadReloadedHasBeenSet; }
  inline void SetFullLoadReloaded(bool value) {
    m_fullLoadReloadedHasBeenSet = true;
    m_fullLoadReloaded = value;
  }
  inline TableStatistics& WithFullLoadReloaded(bool value) {
    SetFullLoadReloaded(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastUpdateTime() const { return m_lastUpdateTime; }
  inline bool LastUpdateTimeHasBeenSet() const { return m_lastUpdateTimeHasBeenSet; }
  template <typename LastUpdateTimeT = Aws::Utils::DateTime>
  void SetLastUpdateTime(LastUpdateTimeT&& value) {
    m_lastUpdateTimeHasBeenSet = true;
    m_lastUpdateTime = std::forward<LastUpdateTimeT>(value);
  }
  template <typename LastUpdateTimeT = Aws::Utils::DateTime>
  TableStatistics& WithLastUpdateTime(LastUpdateTimeT&& value) {
    SetLastUpdateTime(std::forward<LastUpdateTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTableState() const { return m_tableState; }
  inline bool TableStateHasBeenSet() const { return m_tableStateHasBeenSet; }
  template <typename TableStateT = Aws::String>
  void SetTableState(TableStateT&& value) {
    m_tableStateHasBeenSet = true;
    m_tableState = std::forward<TableStateT>(value);
  }
  template <typename TableStateT = Aws::String>
  TableStatistics& WithTableState(TableStateT&& value) {
    SetTableState(std::forward<TableStateT>(value));
    return *this;
  }
 
 
  inline long long GetValidationPendingRecords() const { return m_validationPendingRecords; }
  inline bool ValidationPendingRecordsHasBeenSet() const { return m_validationPendingRecordsHasBeenSet; }
  inline void SetValidationPendingRecords(long long value) {
    m_validationPendingRecordsHasBeenSet = true;
    m_validationPendingRecords = value;
  }
  inline TableStatistics& WithValidationPendingRecords(long long value) {
    SetValidationPendingRecords(value);
    return *this;
  }
 
 
  inline long long GetValidationFailedRecords() const { return m_validationFailedRecords; }
  inline bool ValidationFailedRecordsHasBeenSet() const { return m_validationFailedRecordsHasBeenSet; }
  inline void SetValidationFailedRecords(long long value) {
    m_validationFailedRecordsHasBeenSet = true;
    m_validationFailedRecords = value;
  }
  inline TableStatistics& WithValidationFailedRecords(long long value) {
    SetValidationFailedRecords(value);
    return *this;
  }
 
 
  inline long long GetValidationSuspendedRecords() const { return m_validationSuspendedRecords; }
  inline bool ValidationSuspendedRecordsHasBeenSet() const { return m_validationSuspendedRecordsHasBeenSet; }
  inline void SetValidationSuspendedRecords(long long value) {
    m_validationSuspendedRecordsHasBeenSet = true;
    m_validationSuspendedRecords = value;
  }
  inline TableStatistics& WithValidationSuspendedRecords(long long value) {
    SetValidationSuspendedRecords(value);
    return *this;
  }
 
 
  inline const Aws::String& GetValidationState() const { return m_validationState; }
  inline bool ValidationStateHasBeenSet() const { return m_validationStateHasBeenSet; }
  template <typename ValidationStateT = Aws::String>
  void SetValidationState(ValidationStateT&& value) {
    m_validationStateHasBeenSet = true;
    m_validationState = std::forward<ValidationStateT>(value);
  }
  template <typename ValidationStateT = Aws::String>
  TableStatistics& WithValidationState(ValidationStateT&& value) {
    SetValidationState(std::forward<ValidationStateT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetValidationStateDetails() const { return m_validationStateDetails; }
  inline bool ValidationStateDetailsHasBeenSet() const { return m_validationStateDetailsHasBeenSet; }
  template <typename ValidationStateDetailsT = Aws::String>
  void SetValidationStateDetails(ValidationStateDetailsT&& value) {
    m_validationStateDetailsHasBeenSet = true;
    m_validationStateDetails = std::forward<ValidationStateDetailsT>(value);
  }
  template <typename ValidationStateDetailsT = Aws::String>
  TableStatistics& WithValidationStateDetails(ValidationStateDetailsT&& value) {
    SetValidationStateDetails(std::forward<ValidationStateDetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResyncState() const { return m_resyncState; }
  inline bool ResyncStateHasBeenSet() const { return m_resyncStateHasBeenSet; }
  template <typename ResyncStateT = Aws::String>
  void SetResyncState(ResyncStateT&& value) {
    m_resyncStateHasBeenSet = true;
    m_resyncState = std::forward<ResyncStateT>(value);
  }
  template <typename ResyncStateT = Aws::String>
  TableStatistics& WithResyncState(ResyncStateT&& value) {
    SetResyncState(std::forward<ResyncStateT>(value));
    return *this;
  }
 
 
  inline long long GetResyncRowsAttempted() const { return m_resyncRowsAttempted; }
  inline bool ResyncRowsAttemptedHasBeenSet() const { return m_resyncRowsAttemptedHasBeenSet; }
  inline void SetResyncRowsAttempted(long long value) {
    m_resyncRowsAttemptedHasBeenSet = true;
    m_resyncRowsAttempted = value;
  }
  inline TableStatistics& WithResyncRowsAttempted(long long value) {
    SetResyncRowsAttempted(value);
    return *this;
  }
 
 
  inline long long GetResyncRowsSucceeded() const { return m_resyncRowsSucceeded; }
  inline bool ResyncRowsSucceededHasBeenSet() const { return m_resyncRowsSucceededHasBeenSet; }
  inline void SetResyncRowsSucceeded(long long value) {
    m_resyncRowsSucceededHasBeenSet = true;
    m_resyncRowsSucceeded = value;
  }
  inline TableStatistics& WithResyncRowsSucceeded(long long value) {
    SetResyncRowsSucceeded(value);
    return *this;
  }
 
 
  inline long long GetResyncRowsFailed() const { return m_resyncRowsFailed; }
  inline bool ResyncRowsFailedHasBeenSet() const { return m_resyncRowsFailedHasBeenSet; }
  inline void SetResyncRowsFailed(long long value) {
    m_resyncRowsFailedHasBeenSet = true;
    m_resyncRowsFailed = value;
  }
  inline TableStatistics& WithResyncRowsFailed(long long value) {
    SetResyncRowsFailed(value);
    return *this;
  }
 
 
  inline double GetResyncProgress() const { return m_resyncProgress; }
  inline bool ResyncProgressHasBeenSet() const { return m_resyncProgressHasBeenSet; }
  inline void SetResyncProgress(double value) {
    m_resyncProgressHasBeenSet = true;
    m_resyncProgress = value;
  }
  inline TableStatistics& WithResyncProgress(double value) {
    SetResyncProgress(value);
    return *this;
  }
 private:
  Aws::String m_schemaName;
 
  Aws::String m_tableName;
 
  long long m_inserts{0};
 
  long long m_deletes{0};
 
  long long m_updates{0};
 
  long long m_ddls{0};
 
  long long m_appliedInserts{0};
 
  long long m_appliedDeletes{0};
 
  long long m_appliedUpdates{0};
 
  long long m_appliedDdls{0};
 
  long long m_fullLoadRows{0};
 
  long long m_fullLoadCondtnlChkFailedRows{0};
 
  long long m_fullLoadErrorRows{0};
 
  Aws::Utils::DateTime m_fullLoadStartTime{};
 
  Aws::Utils::DateTime m_fullLoadEndTime{};
 
  bool m_fullLoadReloaded{false};
 
  Aws::Utils::DateTime m_lastUpdateTime{};
 
  Aws::String m_tableState;
 
  long long m_validationPendingRecords{0};
 
  long long m_validationFailedRecords{0};
 
  long long m_validationSuspendedRecords{0};
 
  Aws::String m_validationState;
 
  Aws::String m_validationStateDetails;
 
  Aws::String m_resyncState;
 
  long long m_resyncRowsAttempted{0};
 
  long long m_resyncRowsSucceeded{0};
 
  long long m_resyncRowsFailed{0};
 
  double m_resyncProgress{0.0};
  bool m_schemaNameHasBeenSet = false;
  bool m_tableNameHasBeenSet = false;
  bool m_insertsHasBeenSet = false;
  bool m_deletesHasBeenSet = false;
  bool m_updatesHasBeenSet = false;
  bool m_ddlsHasBeenSet = false;
  bool m_appliedInsertsHasBeenSet = false;
  bool m_appliedDeletesHasBeenSet = false;
  bool m_appliedUpdatesHasBeenSet = false;
  bool m_appliedDdlsHasBeenSet = false;
  bool m_fullLoadRowsHasBeenSet = false;
  bool m_fullLoadCondtnlChkFailedRowsHasBeenSet = false;
  bool m_fullLoadErrorRowsHasBeenSet = false;
  bool m_fullLoadStartTimeHasBeenSet = false;
  bool m_fullLoadEndTimeHasBeenSet = false;
  bool m_fullLoadReloadedHasBeenSet = false;
  bool m_lastUpdateTimeHasBeenSet = false;
  bool m_tableStateHasBeenSet = false;
  bool m_validationPendingRecordsHasBeenSet = false;
  bool m_validationFailedRecordsHasBeenSet = false;
  bool m_validationSuspendedRecordsHasBeenSet = false;
  bool m_validationStateHasBeenSet = false;
  bool m_validationStateDetailsHasBeenSet = false;
  bool m_resyncStateHasBeenSet = false;
  bool m_resyncRowsAttemptedHasBeenSet = false;
  bool m_resyncRowsSucceededHasBeenSet = false;
  bool m_resyncRowsFailedHasBeenSet = false;
  bool m_resyncProgressHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DatabaseMigrationService
}  // namespace Aws