Package io.toro.martini

Class DynamoDbMethods

  • public final class DynamoDbMethods
extends Object
    Dynamodb methods used to communicate in the dynamodb connection and manipulate the data

    • Constructor Detail

      • DynamoDbMethods

        @Autowired
public DynamoDbMethods​(io.toro.martini.database.DataSourceManager manager)

    • Method Detail

      • setDataSourceManager

        static void setDataSourceManager​(io.toro.martini.database.DataSourceManager manager)

      • getDynamoDbClient

        public static software.amazon.awssdk.services.dynamodb.DynamoDbClient getDynamoDbClient​(String connectionName)
        Returns a DynamoDbClient object from the DynamoDbDatabaseSource object
        Parameters:
        connectionName - the name of the mongo db connection registered in Martini Runtime
        Returns:
        DynamoDbClient

      • putItem

        @GloopObjectParameter("output{\ndynamodbOutput#io.toro.martini.dynamodb.DynamoDbResponse{\n}\n}")
public static GloopModel putItem​(@NotNull
                                 @NotNull String databaseConnectionName,
                                 @NotNull
                                 @NotNull String tableName,
                                 @GloopObjectParameter("items#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                 List<GloopModel> items,
                                 @GloopParameter(defaultValue="",choices={"NONE","ALL_OLD"})
                                 String returnValues,
                                 @GloopParameter(defaultValue="",choices={"TOTAL","INDEXES","NONE"})
                                 String returnConsumedCapacity,
                                 @GloopParameter(defaultValue="",choices={"NONE","SIZE"})
                                 String returnItemCollectionMetrics,
                                 String conditionExpression,
                                 Map<String,​String> expressionAttributeNames,
                                 @GloopObjectParameter("expressionAttributeValues#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                 List<GloopModel> expressionAttributeValues)
        Creates a new item, or replaces an old item with a new item and convert the PutItemResponse into gloop model
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        tableName - the name of the table
        items - a map of attribute name/value pairs, one for each attribute as GloopModel
        returnValues - to get the item attributes as they appeared before they were updated
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        returnItemCollectionMetrics - determine whether item collection metrics are returned
        conditionExpression - a condition that must be satisfied in order for a conditional PutItem operation to succeed
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        expressionAttributeValues - one or more values that can be substituted in an expression as GloopModel
        Returns:
        GloopModel

      • putItem

        @GloopObjectParameter("output{\ndynamodbOutput#io.toro.martini.dynamodb.DynamoDbResponse{\n}\n}")
public static GloopModel putItem​(@NotNull
                                 @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                 @NotNull
                                 @NotNull String tableName,
                                 @GloopObjectParameter("items#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                 List<GloopModel> items,
                                 @GloopParameter(defaultValue="",choices={"NONE","ALL_OLD"})
                                 String returnValues,
                                 @GloopParameter(defaultValue="",choices={"TOTAL","INDEXES","NONE"})
                                 String returnConsumedCapacity,
                                 @GloopParameter(defaultValue="",choices={"NONE","SIZE"})
                                 String returnItemCollectionMetrics,
                                 String conditionExpression,
                                 Map<String,​String> expressionAttributeNames,
                                 @GloopObjectParameter("expressionAttributeValues#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                 List<GloopModel> expressionAttributeValues)
        Creates a new item, or replaces an old item with a new item and convert the PutItemResponse into gloop model
        Parameters:
        client - dynamodb client to perform the put item request
        tableName - the name of the table
        items - a map of attribute name/value pairs, one for each attribute as GloopModel
        returnValues - to get the item attributes as they appeared before they were updated
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        returnItemCollectionMetrics - determine whether item collection metrics are returned
        conditionExpression - a condition that must be satisfied in order for a conditional PutItem operation to succeed
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        expressionAttributeValues - one or more values that can be substituted in an expression as GloopModel
        Returns:
        GloopModel

      • updateItem

        @GloopObjectParameter("output{\ndynamodbOutput#io.toro.martini.dynamodb.DynamoDbResponse{\n}\n}")
public static GloopModel updateItem​(@NotNull
                                    @NotNull String databaseConnectionName,
                                    @NotNull
                                    @NotNull String tableName,
                                    @GloopObjectParameter("keys#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                    List<GloopModel> keyModels,
                                    @GloopParameter(defaultValue="",choices={"NONE","ALL_OLD","ALL_NEW","UPDATED_OLD","UPDATED_NEW"})
                                    String returnValues,
                                    @GloopParameter(defaultValue="",choices={"TOTAL","INDEXES","NONE"})
                                    String returnConsumedCapacity,
                                    @GloopParameter(defaultValue="",choices={"NONE","SIZE"})
                                    String returnItemCollectionMetrics,
                                    String conditionExpression,
                                    Map<String,​String> expressionAttributeNames,
                                    @GloopObjectParameter("expressionAttributeValues#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                    List<GloopModel> expressionAttributeValueModels,
                                    String updateExpression)
        Edits an existing item's attributes, or adds a new item to the table if it does not already exist and return UpdateItemResponse as Gloop Model
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        tableName - the name of the table
        keyModels - the primary key of the item to be updated as GloopModel
        returnValues - to get the item attributes as they appeared before they were updated
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        returnItemCollectionMetrics - determine whether item collection metrics are returned
        conditionExpression - a condition that must be satisfied in order for a conditional update to succeed
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        expressionAttributeValueModels - one or more values that can be substituted in an expression as GloopModel
        updateExpression - an expression that defines one or more attributes to be updated
        Returns:
        GloopModel

      • updateItem

        @GloopObjectParameter("output{\ndynamodbOutput#io.toro.martini.dynamodb.DynamoDbResponse{\n}\n}")
public static GloopModel updateItem​(@NotNull
                                    @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                    @NotNull
                                    @NotNull String tableName,
                                    @GloopObjectParameter("keys#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                    List<GloopModel> keyModels,
                                    @GloopParameter(defaultValue="",choices={"NONE","ALL_OLD","ALL_NEW","UPDATED_OLD","UPDATED_NEW"})
                                    String returnValues,
                                    @GloopParameter(defaultValue="",choices={"TOTAL","INDEXES","NONE"})
                                    String returnConsumedCapacity,
                                    @GloopParameter(defaultValue="",choices={"NONE","SIZE"})
                                    String returnItemCollectionMetrics,
                                    String conditionExpression,
                                    Map<String,​String> expressionAttributeNames,
                                    @GloopObjectParameter("expressionAttributeValues#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                    List<GloopModel> expressionAttributeValueModels,
                                    String updateExpression)
        Edits an existing item's attributes, or adds a new item to the table if it does not already exist and return UpdateItemResponse as Gloop Model
        Parameters:
        client - dynamodb client to perform the update item request
        tableName - the name of the table
        keyModels - the primary key of the item to be updated as GloopModel
        returnValues - to get the item attributes as they appeared before they were updated
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        returnItemCollectionMetrics - determine whether item collection metrics are returned
        conditionExpression - a condition that must be satisfied in order for a conditional update to succeed
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        expressionAttributeValueModels - one or more values that can be substituted in an expression as GloopModel
        updateExpression - an expression that defines one or more attributes to be updated
        Returns:
        GloopModel

      • deleteItem

        @GloopObjectParameter("output{\ndynamodbOutput#io.toro.martini.dynamodb.DynamoDbResponse{\n}\n}")
public static GloopModel deleteItem​(@NotNull
                                    @NotNull String databaseConnectionName,
                                    @NotNull
                                    @NotNull String tableName,
                                    @GloopObjectParameter("keys#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                    List<GloopModel> keyModels,
                                    @GloopParameter(defaultValue="",choices={"NONE","ALL_OLD"})
                                    String returnValues,
                                    @GloopParameter(defaultValue="",choices={"TOTAL","INDEXES","NONE"})
                                    String returnConsumedCapacity,
                                    @GloopParameter(defaultValue="",choices={"NONE","SIZE"})
                                    String returnItemCollectionMetrics,
                                    String conditionExpression,
                                    Map<String,​String> expressionAttributeNames,
                                    @GloopObjectParameter("expressionAttributeValues#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                    List<GloopModel> expressionAttributeValueModels)
        Deletes a single item in a table by primary key and return DeleteItemResponse as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        tableName - the name of the table
        keyModels - a map of attribute names to AttributeValue objects, representing the primary key of the item to delete as GloopModel
        returnValues - to get the item attributes as they appeared before they were updated
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        returnItemCollectionMetrics - determine whether item collection metrics are returned
        conditionExpression - a condition that must be satisfied in order for a conditional DeleteItem to succeed
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        expressionAttributeValueModels - one or more values that can be substituted in an expression as GloopModel
        Returns:
        GloopModel

      • deleteItem

        @GloopObjectParameter("output{\ndynamodbOutput#io.toro.martini.dynamodb.DynamoDbResponse{\n}\n}")
public static GloopModel deleteItem​(@NotNull
                                    @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                    @NotNull
                                    @NotNull String tableName,
                                    @GloopObjectParameter("keys#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                    List<GloopModel> keyModels,
                                    @GloopParameter(defaultValue="",choices={"NONE","ALL_OLD"})
                                    String returnValues,
                                    @GloopParameter(defaultValue="",choices={"TOTAL","INDEXES","NONE"})
                                    String returnConsumedCapacity,
                                    @GloopParameter(defaultValue="",choices={"NONE","SIZE"})
                                    String returnItemCollectionMetrics,
                                    String conditionExpression,
                                    Map<String,​String> expressionAttributeNames,
                                    @GloopObjectParameter("expressionAttributeValues#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                    List<GloopModel> expressionAttributeValueModels)
        Deletes a single item in a table by primary key and return DeleteItemResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the delete item request
        tableName - the name of the table
        keyModels - a map of attribute names to AttributeValue objects, representing the primary key of the item to delete as GloopModel
        returnValues - to get the item attributes as they appeared before they were updated
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        returnItemCollectionMetrics - determine whether item collection metrics are returned
        conditionExpression - a condition that must be satisfied in order for a conditional DeleteItem to succeed
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        expressionAttributeValueModels - one or more values that can be substituted in an expression as GloopModel
        Returns:
        GloopModel

      • getItem

        @GloopObjectParameter("output{\ndynamodbOutput#io.toro.martini.dynamodb.DynamoDbResponse{\n}\n}")
public static GloopModel getItem​(@NotNull
                                 @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                 @NotNull
                                 @NotNull String tableName,
                                 @GloopObjectParameter("keys#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                 List<GloopModel> keyModels,
                                 Boolean consistentRead,
                                 @GloopParameter(defaultValue="",choices={"NONE","TOTAL","INDEXES"})
                                 String returnConsumedCapacity,
                                 String projectionExpression,
                                 Map<String,​String> expressionAttributeNames)
        The GetItem operation returns a set of attributes for the item with the given primary key and return GetItemResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the get item request
        tableName - the name of the table
        keyModels - a map of attribute names representing the primary key of the item to retrieve as GloopModel
        consistentRead - determines the read consistency model
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        projectionExpression - a string that identifies one or more attributes to retrieve from the table
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        Returns:
        GloopModel

      • getItem

        @GloopObjectParameter("output{\ndynamodbOutput#io.toro.martini.dynamodb.DynamoDbResponse{\n}\n}")
public static GloopModel getItem​(@NotNull
                                 @NotNull String databaseConnectionName,
                                 @NotNull
                                 @NotNull String tableName,
                                 @GloopObjectParameter("keys#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                 List<GloopModel> keyModels,
                                 Boolean consistentRead,
                                 @GloopParameter(defaultValue="",choices={"NONE","TOTAL","INDEXES"})
                                 String returnConsumedCapacity,
                                 String projectionExpression,
                                 Map<String,​String> expressionAttributeNames)
        The GetItem operation returns a set of attributes for the item with the given primary key and return GetItemResponse as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        tableName - the name of the table
        keyModels - a map of attribute names representing the primary key of the item to retrieve as GloopModel
        consistentRead - determines the read consistency model
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        projectionExpression - a string that identifies one or more attributes to retrieve from the table
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        Returns:
        GloopModel

      • query

        @GloopObjectParameter("output{\ndynamoDbQueryResponse#io.toro.martini.dynamodb.DynamoDbQueryResponse{\n}\n}")
public static GloopModel query​(@NotNull
                               @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                               @NotNull
                               @NotNull String tableName,
                               String indexName,
                               String select,
                               Integer limit,
                               Boolean consistentRead,
                               Boolean scanIndexForward,
                               @GloopObjectParameter("exclusiveStartKey#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                               List<GloopModel> exclusiveStartKeyModels,
                               @GloopParameter(defaultValue="",choices={"NONE","INDEXES","TOTAL"})
                               String returnConsumedCapacity,
                               String projectionExpression,
                               String filterExpression,
                               String keyConditionExpression,
                               Map<String,​String> expressionAttributeNames,
                               @GloopObjectParameter("expressionAttributeValues#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                               List<GloopModel> expressionAttributeValueModels)
        The Query operation finds items based on primary key values and return QueryResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the query table request
        tableName - the name of the table
        indexName - the name of an index to query
        select - the attributes to be returned in the result
        limit - the maximum number of items to evaluate
        consistentRead - determines the read consistency model
        scanIndexForward - determines the read consistency model
        exclusiveStartKeyModels - the primary key of the first item that this operation will evaluate
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        projectionExpression - a string that identifies one or more attributes to retrieve from the table
        filterExpression - a string that contains conditions that DynamoDB applies after the Query operation
        keyConditionExpression - the condition that specifies the key values for items to be retrieved by the Query action
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        expressionAttributeValueModels - one or more values that can be substituted in an expression as GloopModel
        Returns:
        GloopModel

      • query

        @GloopObjectParameter("output{\ndynamoDbQueryResponse#io.toro.martini.dynamodb.DynamoDbQueryResponse{\n}\n}")
public static GloopModel query​(@NotNull
                               @NotNull String databaseConnectionName,
                               @NotNull
                               @NotNull String tableName,
                               String indexName,
                               String select,
                               Integer limit,
                               Boolean consistentRead,
                               Boolean scanIndexForward,
                               @GloopObjectParameter("exclusiveStartKey#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                               List<GloopModel> exclusiveStartKeyModels,
                               @GloopParameter(defaultValue="",choices={"NONE","INDEXES","TOTAL"})
                               String returnConsumedCapacity,
                               String projectionExpression,
                               String filterExpression,
                               String keyConditionExpression,
                               Map<String,​String> expressionAttributeNames,
                               @GloopObjectParameter("expressionAttributeValues#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                               List<GloopModel> expressionAttributeValueModels)
        The Query operation finds items based on primary key values and return QueryResponse as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        tableName - the name of the table
        indexName - the name of an index to query
        select - the attributes to be returned in the result
        limit - the maximum number of items to evaluate
        consistentRead - determines the read consistency model
        scanIndexForward - determines the read consistency model
        exclusiveStartKeyModels - the primary key of the first item that this operation will evaluate
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        projectionExpression - a string that identifies one or more attributes to retrieve from the table
        filterExpression - a string that contains conditions that DynamoDB applies after the Query operation
        keyConditionExpression - the condition that specifies the key values for items to be retrieved by the Query action
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        expressionAttributeValueModels - one or more values that can be substituted in an expression as GloopModel
        Returns:
        GloopModel

      • scanTable

        @GloopObjectParameter("output{\ndynamodbScanResponse#io.toro.martini.dynamodb.DynamoDbQueryResponse{\n}\n}")
public static GloopModel scanTable​(@NotNull
                                   @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                   @NotNull
                                   @NotNull String tableName,
                                   String indexName,
                                   Integer limit,
                                   String select,
                                   Boolean consistentRead,
                                   @GloopObjectParameter("exclusiveStartKey#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                   List<GloopModel> exclusiveStartKeyModels,
                                   @GloopParameter(defaultValue="",choices={"NONE","INDEXES","TOTAL"})
                                   String returnConsumedCapacity,
                                   String projectionExpression,
                                   String filterExpression,
                                   Map<String,​String> expressionAttributeNames,
                                   @GloopObjectParameter("expressionAttributeValues#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                   List<GloopModel> expressionAttributeValueModels,
                                   Integer segment,
                                   Integer totalSegments)
        Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index and return ScanResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the scan table request
        tableName - the name of the table
        indexName - the name of a secondary index to scan
        select - the attributes to be returned in the result
        limit - the maximum number of items to evaluate
        consistentRead - determines the read consistency model during scan
        exclusiveStartKeyModels - the primary key of the first item that this operation will evaluate
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        projectionExpression - a string that identifies one or more attributes to retrieve from the table
        filterExpression - a string that contains conditions that DynamoDB applies after the Scan operation
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        expressionAttributeValueModels - one or more values that can be substituted in an expression as GloopModel
        segment - identifies an individual segment to be scanned by an application worker
        totalSegments - represents the total number of segments into which the Scan operation will be divided
        Returns:
        GloopModel

      • scanTable

        @GloopObjectParameter("output{\ndynamodbScanResponse#io.toro.martini.dynamodb.DynamoDbQueryResponse{\n}\n}")
public static GloopModel scanTable​(@NotNull
                                   @NotNull String databaseConnectionName,
                                   @NotNull
                                   @NotNull String tableName,
                                   String indexName,
                                   Integer limit,
                                   String select,
                                   Boolean consistentRead,
                                   @GloopObjectParameter("exclusiveStartKey#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                   List<GloopModel> exclusiveStartKeyModels,
                                   @GloopParameter(defaultValue="",choices={"NONE","INDEXES","TOTAL"})
                                   String returnConsumedCapacity,
                                   String projectionExpression,
                                   String filterExpression,
                                   Map<String,​String> expressionAttributeNames,
                                   @GloopObjectParameter("expressionAttributeValues#io.toro.martini.dynamodb.MapAttributeValue[]{\n}")
                                   List<GloopModel> expressionAttributeValueModels,
                                   Integer segment,
                                   Integer totalSegments)
        Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index and return ScanResponse as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        tableName - the name of the table
        indexName - the name of a secondary index to scan
        select - the attributes to be returned in the result
        limit - the maximum number of items to evaluate
        consistentRead - determines the read consistency model during scan
        exclusiveStartKeyModels - the primary key of the first item that this operation will evaluate
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        projectionExpression - a string that identifies one or more attributes to retrieve from the table
        filterExpression - a string that contains conditions that DynamoDB applies after the Scan operation
        expressionAttributeNames - one or more substitution tokens for attribute names in an expression
        expressionAttributeValueModels - one or more values that can be substituted in an expression as GloopModel
        segment - identifies an individual segment to be scanned by an application worker
        totalSegments - represents the total number of segments into which the Scan operation will be divided
        Returns:
        GloopModel

      • batchGetItems

        @GloopObjectParameter("output{\nbatchGetItemResponse#io.toro.martini.dynamodb.BatchGetItemResponse{\n}\n}")
public static GloopModel batchGetItems​(@NotNull
                                       @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                       @GloopParameter(defaultValue="",choices={"TOTAL","INDEXES","NONE"})
                                       String returnConsumedCapacity,
                                       @GloopObjectParameter("batchGetItemRequest#io.toro.martini.dynamodb.BatchGetItemRequest[]{\n}")
                                       List<GloopModel> requestItems)
        The BatchGetItem operation returns the attributes of one or more items from one or more tables and return BatchGetItemResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the scan table request
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        requestItems - a map of one or more table names and, for each table, a map that describes one or more items to retrieve from that table as GloopModel
        Returns:
        GloopModel

      • batchGetItems

        @GloopObjectParameter("output{\nbatchGetItemResponse#io.toro.martini.dynamodb.BatchGetItemResponse{\n}\n}")
public static GloopModel batchGetItems​(@NotNull
                                       @NotNull String databaseConnectionName,
                                       @GloopParameter(defaultValue="",choices={"TOTAL","INDEXES","NONE"})
                                       String returnConsumedCapacity,
                                       @GloopObjectParameter("batchGetItemRequest#io.toro.martini.dynamodb.BatchGetItemRequest[]{\n}")
                                       List<GloopModel> requestItems)
        The BatchGetItem operation returns the attributes of one or more items from one or more tables and return BatchGetItemResponse as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        requestItems - a map of one or more table names and, for each table, a map that describes one or more items to retrieve from that table as GloopModel
        Returns:
        GloopModel

      • partiQL

        @GloopObjectParameter("output{\npartiQLResponse#io.toro.martini.dynamodb.PartiQLResponse{\n}\n}")
public static GloopModel partiQL​(@NotNull
                                 @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                 Boolean consistentRead,
                                 String nextToken,
                                 @GloopParameter(allowNull=false)
                                 String statement,
                                 @GloopObjectParameter("parameters#io.toro.martini.dynamodb.AttributeValue[]{\n}")
                                 List<GloopModel> parameters)
        This operation allows you to perform reads and singleton writes on data stored in DynamoDB, using PartiQL and return ExecuteStatementResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the partiQl request
        consistentRead - the consistency of a read operation
        nextToken - set this value to get remaining results
        statement - the PartiQL statement representing the operation to run
        parameters - the parameters for the PartiQL statement
        Returns:
        GloopModel

      • partiQL

        @GloopObjectParameter("output{\npartiQLResponse#io.toro.martini.dynamodb.PartiQLResponse{\n}\n}")
public static GloopModel partiQL​(@NotNull
                                 @NotNull String databaseConnectionName,
                                 Boolean consistentRead,
                                 String nextToken,
                                 String statement,
                                 @GloopObjectParameter("parameters#io.toro.martini.dynamodb.AttributeValue[]{\n}")
                                 List<GloopModel> parameters)
        This operation allows you to perform reads and singleton writes on data stored in DynamoDB, using PartiQL and return ExecuteStatementResponse as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        consistentRead - the consistency of a read operation
        nextToken - set this value to get remaining results
        statement - the PartiQL statement representing the operation to run
        parameters - the parameters for the PartiQL statement as GloopModel
        Returns:
        GloopModel

      • batchPartiQl

        @GloopObjectParameter("output{\nstatementResponse#io.toro.martini.dynamodb.StatementResponse[]{\n}\n}")
public static GloopModel batchPartiQl​(@NotNull
                                      @NotNull String databaseConnectionName,
                                      @GloopObjectParameter("batchStatementRequest#io.toro.martini.dynamodb.StatementRequest[]{\n}")
                                      List<GloopModel> statementRequests)
        This operation allows you to perform batch reads or writes on data stored in DynamoDB, using PartiQL and return BatchExecuteStatementResponse as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        statementRequests - The list of PartiQL statements representing the batch to run as GloopModel
        Returns:
        GloopModel

      • batchPartiQl

        @GloopObjectParameter("output{\nstatementResponse#io.toro.martini.dynamodb.StatementResponse[]{\n}\n}")
public static GloopModel batchPartiQl​(@NotNull
                                      @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                      @GloopObjectParameter("batchStatementRequest#io.toro.martini.dynamodb.StatementRequest[]{\n}")
                                      List<GloopModel> statementRequests)
        This operation allows you to perform batch reads or writes on data stored in DynamoDB, using PartiQL and return BatchExecuteStatementResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the batch partiQl request
        statementRequests - The list of PartiQL statements representing the batch to run as GloopModel
        Returns:
        GloopModel

      • createTable

        @GloopObjectParameter("output{\n createTableResponse#io.toro.martini.dynamodb.TableDescription{\n}\n}")
public static GloopModel createTable​(@NotNull
                                     @NotNull String databaseConnectionName,
                                     @GloopObjectParameter("createTableRequest#io.toro.martini.dynamodb.CreateTableRequest{\n}")
                                     GloopModel createTableRequest)
        The CreateTable operation adds a new table to your account and return CreateTableResponse as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        createTableRequest - describe the input parameter to be able to create table
        Returns:
        GloopModel

      • createTable

        @GloopObjectParameter("output{\n createTableResponse#io.toro.martini.dynamodb.TableDescription{\n}\n}")
public static GloopModel createTable​(@NotNull
                                     @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                     @GloopObjectParameter("createTableRequest#io.toro.martini.dynamodb.CreateTableRequest{\n}")
                                     GloopModel createTableRequest)
        The CreateTable operation adds a new table to your account and return CreateTableResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the create table request
        createTableRequest - describe the input parameter to be able to create table
        Returns:
        GloopModel

      • deleteTable

        @GloopObjectParameter("output{\ntableDescriptionResponse#io.toro.martini.dynamodb.TableDescription{\n}\n}")
public static GloopModel deleteTable​(@NotNull
                                     @NotNull String databaseConnectionName,
                                     @NotNull
                                     @NotNull String tableName)
        The DeleteTable operation deletes a table and all of its items and return table description response as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        tableName - the name of the table to delete
        Returns:
        GloopModel

      • deleteTable

        @GloopObjectParameter("output{\ntableDescriptionResponse#io.toro.martini.dynamodb.TableDescription{\n}\n}")
public static GloopModel deleteTable​(@NotNull
                                     @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                     @NotNull
                                     @NotNull String tableName)
        The DeleteTable operation deletes a table and all of its items and return table description response as GloopModel
        Parameters:
        client - dynamodb client to perform delete table request
        tableName - the name of the table to delete
        Returns:
        GloopModel

      • updateTable

        @GloopObjectParameter("output{\ntableDescriptionResponse#io.toro.martini.dynamodb.TableDescription{\n}\n}")
public static GloopModel updateTable​(@NotNull
                                     @NotNull String databaseConnectionName,
                                     @GloopObjectParameter("updateTableRequest#io.toro.martini.dynamodb.UpdateTableRequest{\n}")
                                     GloopModel model)
        Modifies the provisioned throughput settings, global secondary indexes, or DynamoDB Streams settings for a given table and return table description response as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        model - describe the input parameter to update the table
        Returns:
        GloopModel

      • updateTable

        @GloopObjectParameter("output{\ntableDescriptionResponse#io.toro.martini.dynamodb.TableDescription{\n}\n}")
public static GloopModel updateTable​(@NotNull
                                     @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                     @GloopObjectParameter("updateTableRequest#io.toro.martini.dynamodb.UpdateTableRequest{\n}")
                                     GloopModel model)
        Modifies the provisioned throughput settings, global secondary indexes, or DynamoDB Streams settings for a given table and return table description response as GloopModel
        Parameters:
        client - dynamodb client to perform update table request
        model - describe the input parameter to update the table
        Returns:
        GloopModel

      • describeTable

        @GloopObjectParameter("output{\ntableDescriptionResponse#io.toro.martini.dynamodb.TableDescription{\n}\n}")
public static GloopModel describeTable​(@NotNull
                                       @NotNull String databaseConnectionName,
                                       @NotNull
                                       @NotNull String tableName)
        Describe the table and return information of the table as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        tableName - the name of the table to describe
        Returns:
        GloopModel

      • describeTable

        @GloopObjectParameter("output{\ntableDescriptionResponse#io.toro.martini.dynamodb.TableDescription{\n}\n}")
public static GloopModel describeTable​(@NotNull
                                       @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                       @NotNull
                                       @NotNull String tableName)
        Describe the table and return information of the table as GloopModel
        Parameters:
        client - dynamodb client to perform the describe table request
        tableName - the name of the table to describe
        Returns:
        GloopModel

      • listTables

        @GloopObjectParameter("output{\nlistTablesResponse#io.toro.martini.dynamodb.ListTablesResponse{\n}\n}")
public static GloopModel listTables​(@NotNull
                                    @NotNull String databaseConnectionName,
                                    @GloopParameter(defaultValue="1")
                                    int limit,
                                    String exclusiveStartTableName)
        Return list of table names associated with the current account and endpoint
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        limit - a maximum number of table names to return
        exclusiveStartTableName - the first table name that this operation will evaluate
        Returns:
        GloopModel

      • listTables

        @GloopObjectParameter("output{\nlistTablesResponse#io.toro.martini.dynamodb.ListTablesResponse{\n}\n}")
public static GloopModel listTables​(@NotNull
                                    @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                    Integer limit,
                                    String exclusiveStartTableName)
        Return list of table names associated with the current account and endpoint
        Parameters:
        client - dynamodb client to perform the list table request
        limit - a maximum number of table names to return
        exclusiveStartTableName - the first table name that this operation will evaluate
        Returns:
        GloopModel

      • listGlobalTables

        @GloopObjectParameter("output{\nlistGlobalTablesResponse#io.toro.martini.dynamodb.ListGlobalTablesResponse{\n}\n}")
public static GloopModel listGlobalTables​(@NotNull
                                          @NotNull String databaseConnectionName,
                                          @GloopParameter(defaultValue="1")
                                          int limit,
                                          String exclusiveStartTableName,
                                          String region)
        Lists all global tables that have a replica in the specified Region

        Note: This operation only applies to Version 2017.11.29 (Legacy) of global tables. We recommend using Version 2019.11.21 (Current) when creating new global tables.

        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        limit - a maximum number of table names to return
        exclusiveStartTableName - the first table name that this operation will evaluate
        region - lists the global tables in a specific Region
        Returns:
        GloopModel

      • listGlobalTables

        @GloopObjectParameter("output{\nlistGlobalTablesResponse#io.toro.martini.dynamodb.ListGlobalTablesResponse{\n}\n}")
public static GloopModel listGlobalTables​(@NotNull
                                          @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                          Integer limit,
                                          String exclusiveStartTableName,
                                          String region)
        Lists all global tables that have a replica in the specified Region

        Note: This operation only applies to Version 2017.11.29 (Legacy) of global tables. We recommend using Version 2019.11.21 (Current) when creating new global tables.

        Parameters:
        client - dynamodb client to perform the list global table request
        limit - a maximum number of table names to return
        exclusiveStartTableName - the first table name that this operation will evaluate
        region - lists the global tables in a specific Region
        Returns:
        GloopModel

      • updateGlobalTable

        @GloopObjectParameter("output{\nupdateGlobalTableResponse#io.toro.martini.dynamodb.GlobalTableDescription{\n}\n}")
public static GloopModel updateGlobalTable​(@NotNull
                                           @NotNull String databaseConnectionName,
                                           String globalTableName,
                                           @GloopObjectParameter("replicaUpdate#io.toro.martini.dynamodb.ReplicaUpdate[]{\n}")
                                           List<GloopModel> models)
        Adds or removes replicas in the specified global table and return UpdateGlobalTableResponse as GloopModel

        Note: This operation only applies to Version 2017.11.29 (Legacy) of global tables. We recommend using Version 2019.11.21 (Current) when creating new global tables.

        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        globalTableName - the global table name
        models - describe the input parameters to update table
        Returns:
        GloopModel

      • updateGlobalTable

        @GloopObjectParameter("output{\nupdateGlobalTableResponse#io.toro.martini.dynamodb.GlobalTableDescription{\n}\n}")
public static GloopModel updateGlobalTable​(@NotNull
                                           @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                           String globalTableName,
                                           @GloopObjectParameter("replicaUpdate#io.toro.martini.dynamodb.ReplicaUpdate[]{\n}")
                                           List<GloopModel> models)
        Adds or removes replicas in the specified global table and return UpdateGlobalTableResponse as GloopModel

        Note: This operation only applies to Version 2017.11.29 (Legacy) of global tables. We recommend using Version 2019.11.21 (Current) when creating new global tables.

        Parameters:
        client - dynamodb client to perform the update global table request
        globalTableName - the global table name
        models - describe the input parameters to update table
        Returns:
        GloopModel

      • createGlobalTable

        @GloopObjectParameter("output{\ncreateGlobalTableResponse#io.toro.martini.dynamodb.GlobalTableDescription{\n}\n}")
public static GloopModel createGlobalTable​(@NotNull
                                           @NotNull String databaseConnectionName,
                                           @NotNull
                                           @NotNull String globalTableName,
                                           List<String> regionNames)
        Creates a global table from an existing table and return CreateGlobalTableResponse as GloopModel.

        Note: This operation only applies to Version 2017.11.29 (Legacy) of global tables. We recommend using Version 2019.11.21 (Current) when creating new global tables.

        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        globalTableName - the global table name
        regionNames - the Regions where the global table needs to be created
        Returns:
        GloopModel

      • createGlobalTable

        @GloopObjectParameter("output{\ncreateGlobalTableResponse#io.toro.martini.dynamodb.GlobalTableDescription{\n}\n}")
public static GloopModel createGlobalTable​(@NotNull
                                           @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                           @NotNull
                                           @NotNull String globalTableName,
                                           List<String> regionNames)
        Creates a global table from an existing table and return CreateGlobalTableResponse as GloopModel

        Note: This operation only applies to Version 2017.11.29 (Legacy) of global tables. We recommend using Version 2019.11.21 (Current) when creating new global tables.

        Parameters:
        client - dynamodb client to perform the create global table request
        globalTableName - the global table name
        regionNames - the Regions where the global table needs to be created
        Returns:
        GloopModel

      • describeGlobalTable

        @GloopObjectParameter("output{\ndescribeGlobalTableResponse#io.toro.martini.dynamodb.GlobalTableDescription{\n}\n}")
public static GloopModel describeGlobalTable​(@NotNull
                                             @NotNull String databaseConnectionName,
                                             @NotNull
                                             @NotNull String globalTableName)
        Returns information about the specified global table and return DescribeGlobalTableResponse as GloopModel

        Note: This operation only applies to Version 2017.11.29 (Legacy) of global tables. We recommend using Version 2019.11.21 (Current) when creating new global tables.

        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        globalTableName - the name of the global table
        Returns:
        GloopModel

      • describeGlobalTable

        @GloopObjectParameter("output{\ndescribeGlobalTableResponse#io.toro.martini.dynamodb.GlobalTableDescription{\n}\n}")
public static GloopModel describeGlobalTable​(@NotNull
                                             @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                             @NotNull
                                             @NotNull String globalTableName)
        Returns information about the specified global table and return DescribeGlobalTableResponse as GloopModel

        Note: This operation only applies to Version 2017.11.29 (Legacy) of global tables. We recommend using Version 2019.11.21 (Current) when creating new global tables.

        Parameters:
        client - dynamodb client to perform the describe global table request
        globalTableName - the name of the global table
        Returns:
        GloopModel

      • batchWriteItems

        @GloopObjectParameter("output{\nbatchWriteItemResponse#io.toro.martini.dynamodb.BatchWriteItemResponse{\n}\n}")
public static GloopModel batchWriteItems​(@NotNull
                                         @NotNull String databaseConnectionName,
                                         @GloopObjectParameter("requestItems#io.toro.martini.dynamodb.RequestItem[]{\n}")
                                         List<GloopModel> models,
                                         @GloopParameter(defaultValue="",choices={"INDEXES","TOTAL","NONE"})
                                         String returnConsumedCapacity,
                                         @GloopParameter(defaultValue="",choices={"SIZE","NONE"})
                                         String returnItemCollectionMetrics)
        The BatchWriteItem operation puts or deletes multiple items in one or more tables and return BatchWriteItemResponse as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        models - describe the request items
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        returnItemCollectionMetrics - determines whether item collection metrics are returned
        Returns:
        GloopModel

      • batchWriteItems

        @GloopObjectParameter("output{\nbatchWriteItemResponse#io.toro.martini.dynamodb.BatchWriteItemResponse{\n}\n}")
public static GloopModel batchWriteItems​(@NotNull
                                         @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                         @GloopObjectParameter("requestItems#io.toro.martini.dynamodb.RequestItem[]{\n}")
                                         List<GloopModel> models,
                                         @GloopParameter(defaultValue="",choices={"INDEXES","TOTAL","NONE"})
                                         String returnConsumedCapacity,
                                         @GloopParameter(defaultValue="",choices={"SIZE","NONE"})
                                         String returnItemCollectionMetrics)
        The BatchWriteItem operation puts or deletes multiple items in one or more tables and return BatchWriteItemResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the batch write item request
        models - describe the request items to batch write items
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        returnItemCollectionMetrics - determines whether item collection metrics are returned
        Returns:
        GloopModel

      • executeTransaction

        @GloopObjectParameter("output{\nexecuteTransactionResponse#io.toro.martini.dynamodb.ExecuteTransactionResponse{\n}\n}")
public static GloopModel executeTransaction​(@NotNull
                                            @NotNull String databaseConnectionName,
                                            String clientRequestToken,
                                            @GloopObjectParameter("transactStatements#io.toro.martini.dynamodb.ParameterizedStatement[]{\n}")
                                            List<GloopModel> models)
        This operation allows you to perform transactional reads or writes on data stored in DynamoDB, using PartiQL and return ExecuteTransactionResponse as GloopModel
        Parameters:
        databaseConnectionName - the name of the dynamodb connection registered in Martini Runtime
        clientRequestToken - set this value to get remaining results
        models - describe the parameterized statement to perform execute transaction
        Returns:
        GloopModel

      • executeTransaction

        @GloopObjectParameter("output{\nexecuteTransactionResponse#io.toro.martini.dynamodb.ExecuteTransactionResponse{\n}\n}")
public static GloopModel executeTransaction​(@NotNull
                                            @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                            String clientRequestToken,
                                            @GloopObjectParameter("transactStatements#io.toro.martini.dynamodb.ParameterizedStatement[]{\n}")
                                            List<GloopModel> models)
        This operation allows you to perform transactional reads or writes on data stored in DynamoDB, using PartiQL and return ExecuteTransactionResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the execute transaction request
        clientRequestToken - set this value to get remaining results
        models - describe the parameterized statement to perform execute transaction
        Returns:
        GloopModel

      • transactGetItems

        @GloopObjectParameter("output{\ntransactGetItemResponse#io.toro.martini.dynamodb.TransactGetItemResponse{\n}\n}")
public static GloopModel transactGetItems​(@NotNull
                                          @NotNull String databaseConnectionName,
                                          @GloopParameter(defaultValue="",choices={"INDEXES","TOTAL","NONE"})
                                          String returnConsumedCapacity,
                                          @GloopObjectParameter("transactGetItemsRequest#io.toro.martini.dynamodb.Get[]{\n}")
                                          List<GloopModel> transactGetItemsRequest)
        TransactGetItems is a synchronous operation that atomically retrieves multiple items from one or more tables in a single account and Region and return TransactGetItemResponse as GloopModel
        Parameters:
        databaseConnectionName - databaseConnectionName the name of the dynamodb connection registered in Martini Runtime
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        transactGetItemsRequest - describe TransactGetItem object as GloopModel to perform the TransactGetItems
        Returns:
        GloopModel

      • transactGetItems

        @GloopObjectParameter("output{\ntransactGetItemResponse#io.toro.martini.dynamodb.TransactGetItemResponse{\n}\n}")
public static GloopModel transactGetItems​(@NotNull
                                          @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                          @GloopParameter(defaultValue="",choices={"INDEXES","TOTAL","NONE"})
                                          String returnConsumedCapacity,
                                          @GloopObjectParameter("transactGetItemsRequest#io.toro.martini.dynamodb.Get[]{\n}")
                                          List<GloopModel> transactGetItemsRequest)
        TransactGetItems is a synchronous operation that atomically retrieves multiple items from one or more tables in a single account and Region and return TransactGetItemResponse as GloopModel
        Parameters:
        client - dynamodb client to perform the transact get items request
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        transactGetItemsRequest - describe TransactGetItem object as GloopModel to perform the TransactGetItems
        Returns:
        GloopModel

      • transactWriteItems

        @GloopObjectParameter("output{\ntransactWriteItemResponses#io.toro.martini.dynamodb.TransactWriteItemResponses{\n}\n}")
public static GloopModel transactWriteItems​(@NotNull
                                            @NotNull String databaseConnectionName,
                                            @GloopParameter(defaultValue="",choices={"INDEXES","TOTAL","NONE"})
                                            String returnConsumedCapacity,
                                            @GloopParameter(defaultValue="",choices={"SIZE","NONE"})
                                            String returnItemCollectionMetrics,
                                            String clientRequestToken,
                                            @GloopObjectParameter("transactWriteItemsRequest#io.toro.martini.dynamodb.TransactWriteItem[]{\n}")
                                            List<GloopModel> transactWriteItemsRequest)
        TransactWriteItems is a synchronous write operation that groups up to 100 action requests and return TransactWriteItems as GloopModel
        Parameters:
        databaseConnectionName - databaseConnectionName the name of the dynamodb connection registered in Martini Runtime
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        returnItemCollectionMetrics - determines whether item collection metrics are returned
        clientRequestToken - providing a ClientRequestToken makes the call to TransactWriteItems idempotent
        transactWriteItemsRequest - describe the TransactItems object as GloopModel
        Returns:
        GloopModel

      • transactWriteItems

        @GloopObjectParameter("output{\ntransactWriteItemResponses#io.toro.martini.dynamodb.TransactWriteItemResponses{\n}\n}")
public static GloopModel transactWriteItems​(@NotNull
                                            @NotNull software.amazon.awssdk.services.dynamodb.DynamoDbClient client,
                                            @GloopParameter(defaultValue="",choices={"INDEXES","TOTAL","NONE"})
                                            String returnConsumedCapacity,
                                            @GloopParameter(defaultValue="",choices={"SIZE","NONE"})
                                            String returnItemCollectionMetrics,
                                            String clientRequestToken,
                                            @GloopObjectParameter("transactWriteItemsRequest#io.toro.martini.dynamodb.TransactWriteItem[]{\n}")
                                            List<GloopModel> transactWriteItemsRequest)
        TransactWriteItems is a synchronous write operation that groups up to 100 action requests and return TransactWriteItems as GloopModel
        Parameters:
        client - dynamodb client to perform the transact write items request
        returnConsumedCapacity - level of detail about the throughput consumption that is returned in the response
        returnItemCollectionMetrics - determines whether item collection metrics are returned
        clientRequestToken - providing a ClientRequestToken makes the call to TransactWriteItems idempotent
        transactWriteItemsRequest - describe the TransactItems object as GloopModel
        Returns:
        GloopModel

      • connection

        public static io.toro.martini.database.DynamoDbDataSource connection​(@NotNull
                                                                     @NotNull String connectionName)
        Return dynamodb datasource object
        Parameters:
        connectionName - the name of the saved database connection in Martini
        Returns:
        datasource

      • getAsyncClient

        public software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient getAsyncClient​(@NotNull
                                                                                   @NotNull String connectionName)
        Return dynamoDb Async Client
        Parameters:
        connectionName - the name of the saved database connection in Martini
        Returns:
        dynamoDbAsyncClient

      • getEnhancedAsyncClient

        public software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedAsyncClient getEnhancedAsyncClient​(@NotNull
                                                                                                   @NotNull String connectionName)
        Return DynamoDb Enhanced Async Client
        Parameters:
        connectionName - the name of the saved database connection in Martini
        Returns:
        dynamoDbEnhancedAsyncClient

      • getEnhancedClient

        public software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient getEnhancedClient​(@NotNull
                                                                                         @NotNull String connectionName)
        Return dynamoDb Enhanced Client
        Parameters:
        connectionName - the name of the saved database connection in Martini
        Returns:
        dynamoDbEnhancedClient