Added support for Amazon WorkSpaces Instances API

S3 Tables now supports sort and z-order compaction strategies for Iceberg tables in addition to binpack.
AWS Glue now supports sort and z-order strategy for managed automated compaction for Iceberg tables in addition to binpack.

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.593
+1.11.594

generated/smoke-tests/workspaces-instances/CMakeLists.txt

@@ -0,0 +1,41 @@
+add_project(workspaces-instances-smoke-tests
+"Tests for the AWS WORKSPACES-INSTANCES C++ SDK"
+testing-resources
+aws-cpp-sdk-workspaces-instances
+aws-cpp-sdk-core
+)
+file(GLOB AWS_WORKSPACES-INSTANCES_GENERATED_SMOKE_TEST_SRC
+"${CMAKE_CURRENT_SOURCE_DIR}/../RunTests.cpp"
+"${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
+)
+if(MSVC AND BUILD_SHARED_LIBS)
+    add_definitions(-DGTEST_LINKED_AS_SHARED_LIBRARY=1)
+endif()
+
+if (CMAKE_CROSSCOMPILING)
+    set(AUTORUN_UNIT_TESTS OFF)
+endif()
+
+if (AUTORUN_UNIT_TESTS)
+    enable_testing()
+endif()
+
+if(PLATFORM_ANDROID AND BUILD_SHARED_LIBS)
+    add_library(${PROJECT_NAME} "${AWS_WORKSPACES-INSTANCES_GENERATED_SMOKE_TEST_SRC}")
+else()
+    add_executable(${PROJECT_NAME} "${AWS_WORKSPACES-INSTANCES_GENERATED_SMOKE_TEST_SRC}")
+endif()
+
+set_compiler_flags(${PROJECT_NAME})
+set_compiler_warnings(${PROJECT_NAME})
+
+target_include_directories(${PROJECT_NAME} PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../src/aws-cpp-sdk-workspaces-instances/include)
+
+target_link_libraries(${PROJECT_NAME}
+    ${PROJECT_LIBS})
+
+if(NOT CMAKE_CROSSCOMPILING)
+    SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
+endif()
+

generated/smoke-tests/workspaces-instances/WorkspacesInstancesSmokeTests.cpp

@@ -0,0 +1,46 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+#include <algorithm>
+#include <aws/core/auth/AWSCredentialsProviderChain.h>
+#include <aws/core/client/AsyncCallerContext.h>
+#include <aws/core/client/ClientConfiguration.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/core/http/HttpTypes.h>
+#include <aws/core/utils/Outcome.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <aws/core/utils/memory/AWSMemory.h>
+#include <utility>
+#include <aws/testing/AwsCppSdkGTestSuite.h>
+#include <aws/testing/AwsTestHelpers.h>
+#include <aws/workspaces-instances/WorkspacesInstancesClient.h>
+#include <aws/workspaces-instances/model/ListRegionsRequest.h>
+
+namespace WorkspacesInstancesSmokeTest{
+using namespace Aws::Auth;
+using namespace Aws::Http;
+using namespace Aws::Client;
+
+using namespace Aws::WorkspacesInstances;
+using namespace Aws::WorkspacesInstances::Model;
+class WorkspacesInstancesSmokeTestSuite : public Aws::Testing::AwsCppSdkGTestSuite {
+    public:
+    static const char ALLOCATION_TAG[];
+};
+const char WorkspacesInstancesSmokeTestSuite::ALLOCATION_TAG[] = "WorkspacesInstancesSmokeTest";
+TEST_F(WorkspacesInstancesSmokeTestSuite, ListRegionsSuccess )
+{
+    Aws::WorkspacesInstances::WorkspacesInstancesClientConfiguration clientConfiguration;
+    clientConfiguration.region = "us-east-1";
+    clientConfiguration.useFIPS = false;
+    clientConfiguration.useDualStack = false;
+    auto clientSp = Aws::MakeShared<WorkspacesInstancesClient>(ALLOCATION_TAG, clientConfiguration);
+    //populate input params
+    
+    ListRegionsRequest input;
+    auto outcome = clientSp->ListRegions(input);
+    EXPECT_TRUE( outcome.IsSuccess());
+}
+}

generated/src/aws-cpp-sdk-glue/include/aws/glue/model/CompactionConfiguration.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/glue/Glue_EXPORTS.h>
+#include <aws/glue/model/IcebergCompactionConfiguration.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Glue
+{
+namespace Model
+{
+
+  /**
+   * <p>The configuration for a compaction optimizer. This configuration defines how
+   * data files in your table will be compacted to improve query performance and
+   * reduce storage costs.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/glue-2017-03-31/CompactionConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class CompactionConfiguration
+  {
+  public:
+    AWS_GLUE_API CompactionConfiguration() = default;
+    AWS_GLUE_API CompactionConfiguration(Aws::Utils::Json::JsonView jsonValue);
+    AWS_GLUE_API CompactionConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
+    AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    ///@{
+    /**
+     * <p>The configuration for an Iceberg compaction optimizer.</p>
+     */
+    inline const IcebergCompactionConfiguration& GetIcebergConfiguration() const { return m_icebergConfiguration; }
+    inline bool IcebergConfigurationHasBeenSet() const { return m_icebergConfigurationHasBeenSet; }
+    template<typename IcebergConfigurationT = IcebergCompactionConfiguration>
+    void SetIcebergConfiguration(IcebergConfigurationT&& value) { m_icebergConfigurationHasBeenSet = true; m_icebergConfiguration = std::forward<IcebergConfigurationT>(value); }
+    template<typename IcebergConfigurationT = IcebergCompactionConfiguration>
+    CompactionConfiguration& WithIcebergConfiguration(IcebergConfigurationT&& value) { SetIcebergConfiguration(std::forward<IcebergConfigurationT>(value)); return *this;}
+    ///@}
+  private:
+
+    IcebergCompactionConfiguration m_icebergConfiguration;
+    bool m_icebergConfigurationHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace Glue
+} // namespace Aws

generated/src/aws-cpp-sdk-glue/include/aws/glue/model/CompactionStrategy.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/glue/Glue_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace Glue
+{
+namespace Model
+{
+  enum class CompactionStrategy
+  {
+    NOT_SET,
+    binpack,
+    sort,
+    z_order
+  };
+
+namespace CompactionStrategyMapper
+{
+AWS_GLUE_API CompactionStrategy GetCompactionStrategyForName(const Aws::String& name);
+
+AWS_GLUE_API Aws::String GetNameForCompactionStrategy(CompactionStrategy value);
+} // namespace CompactionStrategyMapper
+} // namespace Model
+} // namespace Glue
+} // namespace Aws

generated/src/aws-cpp-sdk-glue/include/aws/glue/model/IcebergCompactionConfiguration.h

@@ -0,0 +1,75 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/glue/Glue_EXPORTS.h>
+#include <aws/glue/model/CompactionStrategy.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace Glue
+{
+namespace Model
+{
+
+  /**
+   * <p>The configuration for an Iceberg compaction optimizer. This configuration
+   * defines parameters for optimizing the layout of data files in Iceberg
+   * tables.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/glue-2017-03-31/IcebergCompactionConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class IcebergCompactionConfiguration
+  {
+  public:
+    AWS_GLUE_API IcebergCompactionConfiguration() = default;
+    AWS_GLUE_API IcebergCompactionConfiguration(Aws::Utils::Json::JsonView jsonValue);
+    AWS_GLUE_API IcebergCompactionConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
+    AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    ///@{
+    /**
+     * <p>The strategy to use for compaction. Valid values are:</p> <ul> <li> <p>
+     * <code>binpack</code>: Combines small files into larger files, typically
+     * targeting sizes over 100MB, while applying any pending deletes. This is the
+     * recommended compaction strategy for most use cases. </p> </li> <li> <p>
+     * <code>sort</code>: Organizes data based on specified columns which are sorted
+     * hierarchically during compaction, improving query performance for filtered
+     * operations. This strategy is recommended when your queries frequently filter on
+     * specific columns. To use this strategy, you must first define a sort order in
+     * your Iceberg table properties using the <code>sort_order</code> table
+     * property.</p> </li> <li> <p> <code>z-order</code>: Optimizes data organization
+     * by blending multiple attributes into a single scalar value that can be used for
+     * sorting, allowing efficient querying across multiple dimensions. This strategy
+     * is recommended when you need to query data across multiple dimensions
+     * simultaneously. To use this strategy, you must first define a sort order in your
+     * Iceberg table properties using the <code>sort_order</code> table property. </p>
+     * </li> </ul> <p>If an input is not provided, the default value 'binpack' will be
+     * used.</p>
+     */
+    inline CompactionStrategy GetStrategy() const { return m_strategy; }
+    inline bool StrategyHasBeenSet() const { return m_strategyHasBeenSet; }
+    inline void SetStrategy(CompactionStrategy value) { m_strategyHasBeenSet = true; m_strategy = value; }
+    inline IcebergCompactionConfiguration& WithStrategy(CompactionStrategy value) { SetStrategy(value); return *this;}
+    ///@}
+  private:
+
+    CompactionStrategy m_strategy{CompactionStrategy::NOT_SET};
+    bool m_strategyHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace Glue
+} // namespace Aws

generated/src/aws-cpp-sdk-glue/include/aws/glue/model/TableOptimizerConfiguration.h

@@ -7,6 +7,7 @@
 #include <aws/glue/Glue_EXPORTS.h>
 #include <aws/core/utils/memory/stl/AWSString.h>
 #include <aws/glue/model/TableOptimizerVpcConfiguration.h>
+#include <aws/glue/model/CompactionConfiguration.h>
 #include <aws/glue/model/RetentionConfiguration.h>
 #include <aws/glue/model/OrphanFileDeletionConfiguration.h>
 #include <utility>
@@ -79,6 +80,20 @@ namespace Model
     TableOptimizerConfiguration& WithVpcConfiguration(VpcConfigurationT&& value) { SetVpcConfiguration(std::forward<VpcConfigurationT>(value)); return *this;}
     ///@}
 
+    ///@{
+    /**
+     * <p>The configuration for a compaction optimizer. This configuration defines how
+     * data files in your table will be compacted to improve query performance and
+     * reduce storage costs.</p>
+     */
+    inline const CompactionConfiguration& GetCompactionConfiguration() const { return m_compactionConfiguration; }
+    inline bool CompactionConfigurationHasBeenSet() const { return m_compactionConfigurationHasBeenSet; }
+    template<typename CompactionConfigurationT = CompactionConfiguration>
+    void SetCompactionConfiguration(CompactionConfigurationT&& value) { m_compactionConfigurationHasBeenSet = true; m_compactionConfiguration = std::forward<CompactionConfigurationT>(value); }
+    template<typename CompactionConfigurationT = CompactionConfiguration>
+    TableOptimizerConfiguration& WithCompactionConfiguration(CompactionConfigurationT&& value) { SetCompactionConfiguration(std::forward<CompactionConfigurationT>(value)); return *this;}
+    ///@}
+
     ///@{
     /**
      * <p>The configuration for a snapshot retention optimizer.</p>
@@ -113,6 +128,9 @@ namespace Model
     TableOptimizerVpcConfiguration m_vpcConfiguration;
     bool m_vpcConfigurationHasBeenSet = false;
 
+    CompactionConfiguration m_compactionConfiguration;
+    bool m_compactionConfigurationHasBeenSet = false;
+
     RetentionConfiguration m_retentionConfiguration;
     bool m_retentionConfigurationHasBeenSet = false;
 

generated/src/aws-cpp-sdk-glue/include/aws/glue/model/TableOptimizerRun.h

@@ -9,6 +9,7 @@
 #include <aws/core/utils/DateTime.h>
 #include <aws/core/utils/memory/stl/AWSString.h>
 #include <aws/glue/model/CompactionMetrics.h>
+#include <aws/glue/model/CompactionStrategy.h>
 #include <aws/glue/model/RetentionMetrics.h>
 #include <aws/glue/model/OrphanFileDeletionMetrics.h>
 #include <utility>
@@ -102,6 +103,32 @@ namespace Model
     TableOptimizerRun& WithCompactionMetrics(CompactionMetricsT&& value) { SetCompactionMetrics(std::forward<CompactionMetricsT>(value)); return *this;}
     ///@}
 
+    ///@{
+    /**
+     * <p>The strategy used for the compaction run. Indicates which algorithm was
+     * applied to determine how files were selected and combined during the compaction
+     * process. Valid values are:</p> <ul> <li> <p> <code>binpack</code>: Combines
+     * small files into larger files, typically targeting sizes over 100MB, while
+     * applying any pending deletes. This is the recommended compaction strategy for
+     * most use cases. </p> </li> <li> <p> <code>sort</code>: Organizes data based on
+     * specified columns which are sorted hierarchically during compaction, improving
+     * query performance for filtered operations. This strategy is recommended when
+     * your queries frequently filter on specific columns. To use this strategy, you
+     * must first define a sort order in your Iceberg table properties using the
+     * <code>sort_order</code> table property.</p> </li> <li> <p> <code>z-order</code>:
+     * Optimizes data organization by blending multiple attributes into a single scalar
+     * value that can be used for sorting, allowing efficient querying across multiple
+     * dimensions. This strategy is recommended when you need to query data across
+     * multiple dimensions simultaneously. To use this strategy, you must first define
+     * a sort order in your Iceberg table properties using the <code>sort_order</code>
+     * table property. </p> </li> </ul>
+     */
+    inline CompactionStrategy GetCompactionStrategy() const { return m_compactionStrategy; }
+    inline bool CompactionStrategyHasBeenSet() const { return m_compactionStrategyHasBeenSet; }
+    inline void SetCompactionStrategy(CompactionStrategy value) { m_compactionStrategyHasBeenSet = true; m_compactionStrategy = value; }
+    inline TableOptimizerRun& WithCompactionStrategy(CompactionStrategy value) { SetCompactionStrategy(value); return *this;}
+    ///@}
+
     ///@{
     /**
      * <p>A <code>RetentionMetrics</code> object containing metrics for the optimizer
@@ -144,6 +171,9 @@ namespace Model
     CompactionMetrics m_compactionMetrics;
     bool m_compactionMetricsHasBeenSet = false;
 
+    CompactionStrategy m_compactionStrategy{CompactionStrategy::NOT_SET};
+    bool m_compactionStrategyHasBeenSet = false;
+
     RetentionMetrics m_retentionMetrics;
     bool m_retentionMetricsHasBeenSet = false;