public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
var useParameterSelect = this.Select.StartsWith("^");
// create request and set iteration invariants
var request = new Amazon.DynamoDBv2.Model.ListTablesRequest();
if (cmdletContext.Limit != null)
{
request.Limit = AutoIterationHelpers.ConvertEmitLimitToServiceTypeInt32(cmdletContext.Limit.Value);
}
// Initialize loop variant and commence piping
var _nextToken = cmdletContext.ExclusiveStartTableName;
var _userControllingPaging = this.NoAutoIteration.IsPresent || ParameterWasBound(nameof(this.ExclusiveStartTableName));
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
do
{
request.ExclusiveStartTableName = _nextToken;
CmdletOutput output;
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
if (!useParameterSelect)
{
pipelineOutput = cmdletContext.Select(response, this);
}
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
_nextToken = response.LastEvaluatedTableName;
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
ProcessOutput(output);
} while (!_userControllingPaging && AutoIterationHelpers.HasValue(_nextToken));
if (useParameterSelect)
{
WriteObject(cmdletContext.Select(null, this));
}
return(null);
}
IAsyncResult invokeListTables(ListTablesRequest listTablesRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new ListTablesRequestMarshaller().Marshall(listTablesRequest);
var unmarshaller = ListTablesResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
/// <summary>
/// Returns an array of table names associated with the current account and endpoint.
/// The output from <i>ListTables</i> is paginated, with each page returning a maximum
/// of 100 table names.
/// </summary>
/// <param name="limit"> A maximum number of table names to return. If this parameter is not specified, the limit is 100.</param>
///
/// <returns>The response from the ListTables service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
public ListTablesResponse ListTables(int limit)
{
var request = new ListTablesRequest();
request.Limit = limit;
return ListTables(request);
}
/// <summary>
/// Returns an array of table names associated with the current account and endpoint.
/// The output from <i>ListTables</i> is paginated, with each page returning a maximum
/// of 100 table names.
/// </summary>
/// <param name="limit"> A maximum number of table names to return. If this parameter is not specified, the limit is 100.</param>
///
/// <returns>The response from the ListTables service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
public void ListTablesAsync(int limit, AmazonServiceCallback<ListTablesRequest, ListTablesResponse> callback, AsyncOptions options = null)
{
var request = new ListTablesRequest();
request.Limit = limit;
ListTablesAsync(request, callback, options);
}
private Amazon.DynamoDBv2.Model.ListTablesResponse CallAWSServiceOperation(IAmazonDynamoDB client, Amazon.DynamoDBv2.Model.ListTablesRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon DynamoDB", "ListTables");
try
{
#if DESKTOP
return(client.ListTables(request));
#elif CORECLR
return(client.ListTablesAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
internal ListTablesResponse ListTables(ListTablesRequest request)
{
var marshaller = new ListTablesRequestMarshaller();
var unmarshaller = ListTablesResponseUnmarshaller.Instance;
return Invoke<ListTablesRequest,ListTablesResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Initiates the asynchronous execution of the ListTables operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListTables operation on AmazonDynamoDBClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTables
/// operation.</returns>
public IAsyncResult BeginListTables(ListTablesRequest request, AsyncCallback callback, object state)
{
var marshaller = new ListTablesRequestMarshaller();
var unmarshaller = ListTablesResponseUnmarshaller.Instance;
return BeginInvoke<ListTablesRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// Paginator for ListTables operation
///</summary>
public IListTablesPaginator ListTables(ListTablesRequest request)
{
return(new ListTablesPaginator(this.client, request));
}
/// <summary>
/// Initiates the asynchronous execution of the ListTables operation.
/// <seealso cref="Amazon.DynamoDBv2.IAmazonDynamoDB.ListTables"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListTables operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task<ListTablesResponse> ListTablesAsync(ListTablesRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new ListTablesRequestMarshaller();
var unmarshaller = ListTablesResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, ListTablesRequest, ListTablesResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
internal ListTablesResponse ListTables(ListTablesRequest request)
{
var task = ListTablesAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
static void Main(string[] args)
{
var config = new AmazonDynamoDBConfig();
config.ServiceURL = "http://localhost:8000";
AmazonDynamoDBClient client = new AmazonDynamoDBClient(config);
string tableName = "MonthlyTotals";
bool tableExists = false;
string lastEvaluatedTableName = null;
do
{
// Create a request object to specify optional parameters.
var req = new ListTablesRequest
{
Limit = 10, // Page size.
ExclusiveStartTableName = lastEvaluatedTableName
};
var tblres = client.ListTables(req);
foreach (string name in tblres.TableNames) {
if (name.Equals(tableName))
{
tableExists = true;
break;
}
}
if (tableExists)
{
break;
}
lastEvaluatedTableName = tblres.LastEvaluatedTableName;
} while (lastEvaluatedTableName != null);
if (!tableExists)
{
//Table doesnt exist, lets create it
var request = new CreateTableRequest
{
TableName = tableName,
AttributeDefinitions = new List<AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "SKUId",
AttributeType = "N"
},
new AttributeDefinition
{
AttributeName = "Month",
AttributeType = "S"
}
},
KeySchema = new List<KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "SKUId",
KeyType = "HASH" //Partition key
},
new KeySchemaElement
{
AttributeName = "Month",
KeyType = "RANGE"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
};
CreateTableResponse response = client.CreateTable(request);
var tableDescription = response.TableDescription;
Console.WriteLine("{1}: {0} \t ReadCapacityUnits: {2} \t WriteCapacityUnits: {3}",
tableDescription.TableStatus,
tableDescription.TableName,
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);
string status = tableDescription.TableStatus;
}
var res = client.DescribeTable(new DescribeTableRequest { TableName = tableName });
Console.WriteLine(tableName + " - " + res.Table.TableStatus);
Console.WriteLine();
Console.WriteLine("Test Crud?");
Console.ReadLine();
DynamoDBContext context = new DynamoDBContext(client);
TestCRUDOperations(context);
Console.ReadLine();
}
public void DataPlaneSamples()
{
{
#region CreateTable Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define table schema:
// Table has a hash-key "Author" and a range-key "Title"
List<KeySchemaElement> schema = new List<KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "Author", KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "Title", KeyType = "RANGE"
}
};
// Define key attributes:
// The key attributes "Author" and "Title" are string types
List<AttributeDefinition> definitions = new List<AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "Author", AttributeType = "S"
},
new AttributeDefinition
{
AttributeName = "Title", AttributeType = "S"
}
};
// Define table throughput:
// Table has capacity of 20 reads and 50 writes
ProvisionedThroughput throughput = new ProvisionedThroughput
{
ReadCapacityUnits = 20,
WriteCapacityUnits = 50
};
// Configure the CreateTable request
CreateTableRequest request = new CreateTableRequest
{
TableName = "SampleTable",
KeySchema = schema,
ProvisionedThroughput = throughput,
AttributeDefinitions = definitions
};
// View new table properties
TableDescription tableDescription = client.CreateTable(request).TableDescription;
Console.WriteLine("Table name: {0}", tableDescription.TableName);
Console.WriteLine("Creation time: {0}", tableDescription.CreationDateTime);
Console.WriteLine("Item count: {0}", tableDescription.ItemCount);
Console.WriteLine("Table size (bytes): {0}", tableDescription.TableSizeBytes);
Console.WriteLine("Table status: {0}", tableDescription.TableStatus);
// List table key schema
List<KeySchemaElement> tableSchema = tableDescription.KeySchema;
for (int i = 0; i < tableSchema.Count; i++)
{
KeySchemaElement element = tableSchema[i];
Console.WriteLine("Key: Name = {0}, KeyType = {1}",
element.AttributeName, element.KeyType);
}
// List attribute definitions
List<AttributeDefinition> attributeDefinitions = tableDescription.AttributeDefinitions;
for (int i = 0; i < attributeDefinitions.Count; i++)
{
AttributeDefinition definition = attributeDefinitions[i];
Console.WriteLine("Attribute: Name = {0}, Type = {1}",
definition.AttributeName, definition.AttributeType);
}
Console.WriteLine("Throughput: Reads = {0}, Writes = {1}",
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);
#endregion
}
{
#region DescribeTable Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Create DescribeTable request
DescribeTableRequest request = new DescribeTableRequest
{
TableName = "SampleTable"
};
// Issue DescribeTable request and retrieve the table description
TableDescription tableDescription = client.DescribeTable(request).Table;
// View new table properties
Console.WriteLine("Table name: {0}", tableDescription.TableName);
Console.WriteLine("Creation time: {0}", tableDescription.CreationDateTime);
Console.WriteLine("Item count: {0}", tableDescription.ItemCount);
Console.WriteLine("Table size (bytes): {0}", tableDescription.TableSizeBytes);
Console.WriteLine("Table status: {0}", tableDescription.TableStatus);
// List table key schema
List<KeySchemaElement> tableSchema = tableDescription.KeySchema;
for (int i = 0; i < tableSchema.Count; i++)
{
KeySchemaElement element = tableSchema[i];
Console.WriteLine("Key: Name = {0}, KeyType = {1}",
element.AttributeName, element.KeyType);
}
// List attribute definitions
List<AttributeDefinition> attributeDefinitions = tableDescription.AttributeDefinitions;
for (int i = 0; i < attributeDefinitions.Count; i++)
{
AttributeDefinition definition = attributeDefinitions[i];
Console.WriteLine("Attribute: Name = {0}, Type = {1}",
definition.AttributeName, definition.AttributeType);
}
Console.WriteLine("Throughput: Reads = {0}, Writes = {1}",
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);
#endregion
}
{
#region ListTables Paging Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string startTableName = null;
do
{
// Configure ListTables request with the marker value
ListTablesRequest request = new ListTablesRequest
{
ExclusiveStartTableName = startTableName,
};
// Issue call
ListTablesResult result = client.ListTables(request);
// List retrieved tables
List<string> tables = result.TableNames;
Console.WriteLine("Retrieved tables: {0}",
string.Join(", ", tables));
// Update marker value from the result
startTableName = result.LastEvaluatedTableName;
} while (!string.IsNullOrEmpty(startTableName)); // Test marker value
#endregion
}
{
#region ListTables NonPaging Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Issue call
ListTablesResult result = client.ListTables();
// List retrieved tables
List<string> tables = result.TableNames;
Console.WriteLine("Retrieved tables: {0}",
string.Join(", ", tables));
#endregion
}
TableUtils.WaitUntilTableActive("SampleTable", TestClient);
{
#region UpdateTable Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define new table throughput:
// Table will now have capacity of 40 reads and 50 writes
ProvisionedThroughput throughput = new ProvisionedThroughput
{
ReadCapacityUnits = 40,
WriteCapacityUnits = 50
};
// Compose the UpdateTable request
UpdateTableRequest request = new UpdateTableRequest
{
TableName = "SampleTable",
ProvisionedThroughput = throughput
};
// View new table properties
TableDescription tableDescription = client.UpdateTable(request).TableDescription;
Console.WriteLine("Table name: {0}", tableDescription.TableName);
Console.WriteLine("Throughput: Reads = {0}, Writes = {1}",
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);
#endregion
}
TableUtils.WaitUntilTableActive("SampleTable", TestClient);
{
#region DeleteTable Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Configure the DeleteTable request
DeleteTableRequest request = new DeleteTableRequest
{
TableName = "SampleTable"
};
// Issue DeleteTable request and retrieve the table description
TableDescription tableDescription = client.DeleteTable(request).TableDescription;
Console.WriteLine("Table name: {0}", tableDescription.TableName);
Console.WriteLine("Table status: {0}", tableDescription.TableStatus);
#endregion
}
}
/// <summary>
/// Initiates the asynchronous execution of the ListTables operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListTables operation on AmazonDynamoDBClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void ListTablesAsync(ListTablesRequest request, AmazonServiceCallback<ListTablesRequest, ListTablesResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new ListTablesRequestMarshaller();
var unmarshaller = ListTablesResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<ListTablesRequest,ListTablesResponse> responseObject
= new AmazonServiceResult<ListTablesRequest,ListTablesResponse>((ListTablesRequest)req, (ListTablesResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<ListTablesRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Initiates the asynchronous execution of the ListTables operation.
/// <seealso cref="Amazon.DynamoDBv2.AmazonDynamoDB.ListTables"/>
/// </summary>
///
/// <param name="listTablesRequest">Container for the necessary parameters to execute the ListTables operation on AmazonDynamoDBv2.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTables
/// operation.</returns>
public IAsyncResult BeginListTables(ListTablesRequest listTablesRequest, AsyncCallback callback, object state)
{
return invokeListTables(listTablesRequest, callback, state, false);
}
/// <summary>
/// Returns an array of table names associated with the current account and endpoint.
/// The output from <i>ListTables</i> is paginated, with each page returning a maximum
/// of 100 table names.
/// </summary>
/// <param name="exclusiveStartTableName">The first table name that this operation will evaluate. Use the value that was returned for <i>LastEvaluatedTableName</i> in a previous operation, so that you can obtain the next page of results.</param>
/// <param name="limit"> A maximum number of table names to return. If this parameter is not specified, the limit is 100.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the ListTables service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
public Task<ListTablesResponse> ListTablesAsync(string exclusiveStartTableName, int limit, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new ListTablesRequest();
request.ExclusiveStartTableName = exclusiveStartTableName;
request.Limit = limit;
return ListTablesAsync(request, cancellationToken);
}
/// <summary>
/// <para>Returns an array of all the tables associated with the current account and endpoint. </para> <para>Each Amazon DynamoDB endpoint is
/// entirely independent. For example, if you have two tables called "MyTable," one in <i>dynamodb.us-east-1.amazonaws.com</i> and one in
/// <i>dynamodb.us-west-1.amazonaws.com</i> , they are completely independent and do not share any data. The <i>ListTables</i> operation returns
/// all of the table names associated with the account making the request, for the endpoint that receives the request.</para>
/// </summary>
///
/// <param name="listTablesRequest">Container for the necessary parameters to execute the ListTables service method on AmazonDynamoDBv2.</param>
///
/// <returns>The response from the ListTables service method, as returned by AmazonDynamoDBv2.</returns>
///
/// <exception cref="InternalServerErrorException"/>
public ListTablesResponse ListTables(ListTablesRequest listTablesRequest)
{
IAsyncResult asyncResult = invokeListTables(listTablesRequest, null, null, true);
return EndListTables(asyncResult);
}
/// <summary>
/// Returns an array of table names associated with the current account and endpoint.
/// The output from <i>ListTables</i> is paginated, with each page returning a maximum
/// of 100 table names.
/// </summary>
/// <param name="limit"> A maximum number of table names to return. If this parameter is not specified, the limit is 100.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the ListTables service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
public Task<ListTablesResponse> ListTablesAsync(int limit, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new ListTablesRequest();
request.Limit = limit;
return ListTablesAsync(request, cancellationToken);
}
internal ListTablesPaginator(IAmazonDynamoDB client, ListTablesRequest request)
{
this._client = client;
this._request = request;
}
internal ListTablesResponse ListTables(ListTablesRequest request)
{
var task = ListTablesAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// Initiates the asynchronous execution of the ListTables operation.
/// <seealso cref="Amazon.DynamoDBv2.IAmazonDynamoDB"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListTables operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<ListTablesResponse> ListTablesAsync(ListTablesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new ListTablesRequestMarshaller();
var unmarshaller = ListTablesResponseUnmarshaller.Instance;
return InvokeAsync<ListTablesRequest,ListTablesResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// <para>Returns an array of table names associated with the current account and endpoint. The output from <i>ListTables</i> is paginated, with
/// each page returning a maximum of 100 table names.</para>
/// </summary>
///
/// <param name="listTablesRequest">Container for the necessary parameters to execute the ListTables service method on AmazonDynamoDBv2.</param>
///
/// <returns>The response from the ListTables service method, as returned by AmazonDynamoDBv2.</returns>
///
/// <exception cref="T:Amazon.DynamoDBv2.Model.InternalServerErrorException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task<ListTablesResponse> ListTablesAsync(ListTablesRequest listTablesRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new ListTablesRequestMarshaller();
var unmarshaller = ListTablesResponseUnmarshaller.GetInstance();
return Invoke<IRequest, ListTablesRequest, ListTablesResponse>(listTablesRequest, marshaller, unmarshaller, signer, cancellationToken);
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
var useParameterSelect = this.Select.StartsWith("^");
// create request and set iteration invariants
var request = new Amazon.DynamoDBv2.Model.ListTablesRequest();
// Initialize loop variants and commence piping
System.String _nextToken = null;
int? _emitLimit = null;
int _retrievedSoFar = 0;
if (AutoIterationHelpers.HasValue(cmdletContext.ExclusiveStartTableName))
{
_nextToken = cmdletContext.ExclusiveStartTableName;
}
if (cmdletContext.Limit.HasValue)
{
// The service has a maximum page size of 100. If the user has
// asked for more items than page max, and there is no page size
// configured, we rely on the service ignoring the set maximum
// and giving us 100 items back. If a page size is set, that will
// be used to configure the pagination.
// We'll make further calls to satisfy the user's request.
_emitLimit = cmdletContext.Limit;
}
var _userControllingPaging = this.NoAutoIteration.IsPresent || ParameterWasBound(nameof(this.ExclusiveStartTableName));
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
do
{
request.ExclusiveStartTableName = _nextToken;
if (_emitLimit.HasValue)
{
int correctPageSize = Math.Min(100, _emitLimit.Value);
request.Limit = AutoIterationHelpers.ConvertEmitLimitToInt32(correctPageSize);
}
CmdletOutput output;
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
if (!useParameterSelect)
{
pipelineOutput = cmdletContext.Select(response, this);
}
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
int _receivedThisCall = response.TableNames.Count;
_nextToken = response.LastEvaluatedTableName;
_retrievedSoFar += _receivedThisCall;
if (_emitLimit.HasValue)
{
_emitLimit -= _receivedThisCall;
}
}
catch (Exception e)
{
if (_retrievedSoFar == 0 || !_emitLimit.HasValue)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
else
{
break;
}
}
ProcessOutput(output);
} while (!_userControllingPaging && AutoIterationHelpers.HasValue(_nextToken) && (!_emitLimit.HasValue || _emitLimit.Value >= 1));
if (useParameterSelect)
{
WriteObject(cmdletContext.Select(null, this));
}
return(null);
}
/// <summary>
/// Returns an array of table names associated with the current account and endpoint.
/// The output from <i>ListTables</i> is paginated, with each page returning a maximum
/// of 100 table names.
/// </summary>
/// <param name="exclusiveStartTableName">The first table name that this operation will evaluate. Use the value that was returned for <i>LastEvaluatedTableName</i> in a previous operation, so that you can obtain the next page of results.</param>
/// <param name="limit"> A maximum number of table names to return. If this parameter is not specified, the limit is 100.</param>
///
/// <returns>The response from the ListTables service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
public ListTablesResponse ListTables(string exclusiveStartTableName, int limit)
{
var request = new ListTablesRequest();
request.ExclusiveStartTableName = exclusiveStartTableName;
request.Limit = limit;
return ListTables(request);
}
void ListTableListener()
{
resultText.text = "\n*** listing tables ***";
string lastTableNameEvaluated = null;
var request = new ListTablesRequest
{
Limit = 2,
ExclusiveStartTableName = lastTableNameEvaluated
};
Client.ListTablesAsync(request, (result) =>
{
if (result.Exception != null)
{
resultText.text += result.Exception.Message;
return;
}
resultText.text += "ListTable response : \n";
var response = result.Response;
foreach (string name in response.TableNames)
resultText.text += name + "\n";
// repeat request to fetch more results
lastTableNameEvaluated = response.LastEvaluatedTableName;
});
}
/// <summary>
/// Returns an array of table names associated with the current account and endpoint.
/// The output from <i>ListTables</i> is paginated, with each page returning a maximum
/// of 100 table names.
/// </summary>
/// <param name="exclusiveStartTableName">The first table name that this operation will evaluate. Use the value that was returned for <i>LastEvaluatedTableName</i> in a previous operation, so that you can obtain the next page of results.</param>
/// <param name="limit"> A maximum number of table names to return. If this parameter is not specified, the limit is 100.</param>
///
/// <returns>The response from the ListTables service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
public void ListTablesAsync(string exclusiveStartTableName, int limit, AmazonServiceCallback<ListTablesRequest, ListTablesResponse> callback, AsyncOptions options = null)
{
var request = new ListTablesRequest();
request.ExclusiveStartTableName = exclusiveStartTableName;
request.Limit = limit;
ListTablesAsync(request, callback, options);
}
