public static void Example()
{
// Create an Amazon Athena client
var athenaConfig = new AmazonAthenaConfig
{
RegionEndpoint = RegionEndpoint.USEast1,
Timeout = TimeSpan.FromMilliseconds(ExampleConstants.CLIENT_EXECUTION_TIMEOUT)
};
var athenaClient = new AmazonAthenaClient(config: athenaConfig);
String sampleQueryExecutionId = submitAthenaQuery(athenaClient);
// Submit the stop query Request
var stopQueryExecutionRequest = new StopQueryExecutionRequest()
{
QueryExecutionId = sampleQueryExecutionId
};
var stopQueryExecutionResponse = athenaClient.StopQueryExecution(stopQueryExecutionRequest);
// Ensure that the query was stopped
var getQueryExecutionRequest = new GetQueryExecutionRequest()
{
QueryExecutionId = sampleQueryExecutionId
};
var getQueryExecutionResponse = athenaClient.GetQueryExecution(getQueryExecutionRequest);
if (getQueryExecutionResponse.QueryExecution.Status.State == QueryExecutionState.CANCELLED)
{
Console.WriteLine("Query has been cancelled");
}
}
internal virtual GetQueryExecutionResponse GetQueryExecution(GetQueryExecutionRequest request)
{
var marshaller = GetQueryExecutionRequestMarshaller.Instance;
var unmarshaller = GetQueryExecutionResponseUnmarshaller.Instance;
return(Invoke <GetQueryExecutionRequest, GetQueryExecutionResponse>(request, marshaller, unmarshaller));
}
/**
* Wait for an Athena query to complete, fail or to be cancelled. This is done by polling Athena over an
* interval of time. If a query fails or is cancelled, then it will throw an exception.
*/
private static void waitForQueryToComplete(AmazonAthenaClient athenaClient, String queryExecutionId)
{
var getQueryExecutionRequest = new GetQueryExecutionRequest()
{
QueryExecutionId = queryExecutionId
};
GetQueryExecutionResponse getQueryExecutionResponse = null;
bool isQueryStillRunning = true;
while (isQueryStillRunning)
{
getQueryExecutionResponse = athenaClient.GetQueryExecution(getQueryExecutionRequest);
var queryState = getQueryExecutionResponse.QueryExecution.Status.State;
if (queryState == QueryExecutionState.FAILED)
{
throw new Exception("Query Failed to run with Error Message: " + getQueryExecutionResponse.QueryExecution.Status.StateChangeReason);
}
else if (queryState == QueryExecutionState.CANCELLED)
{
throw new Exception("Query was cancelled.");
}
else if (queryState == QueryExecutionState.SUCCEEDED)
{
isQueryStillRunning = false;
}
else
{
// Sleep an amount of time before retrying again.
Thread.Sleep(TimeSpan.FromMilliseconds(ExampleConstants.SLEEP_AMOUNT_IN_MS));
}
Console.WriteLine("Current Status is: " + queryState);
}
}
public async Task <bool> IsExecutionCompleted(string executionId) // Task<GetQueryResultsResponse>
{
GetQueryExecutionRequest getQueryExecutionRequest = new GetQueryExecutionRequest()
{
QueryExecutionId = executionId
};
bool completed = false;
var executionResponse = await amazonAthenaClient.GetQueryExecutionAsync(getQueryExecutionRequest);
var state = executionResponse.QueryExecution.Status.State;
if (state == QueryExecutionState.FAILED)
{
throw new Exception($"Query Failed to run with Error Message: \n{executionResponse.QueryExecution.Status.StateChangeReason}");
}
else if (state == QueryExecutionState.CANCELLED)
{
throw new Exception($"Query was cancelled.");
}
else if (state == QueryExecutionState.SUCCEEDED)
{
completed = true;
}
return(completed);
}
private async Task WaitForQueryToComplete(AmazonAthenaClient client, string queryExecutionId)
{
GetQueryExecutionRequest getQueryExecutionRequest = new GetQueryExecutionRequest();
getQueryExecutionRequest.QueryExecutionId = queryExecutionId;
bool isQueryStillRunning = true;
while (isQueryStillRunning)
{
var queryExecutionResponse = await client.GetQueryExecutionAsync(getQueryExecutionRequest);
QueryExecutionStatus queryStatus = queryExecutionResponse.QueryExecution.Status;
if (queryStatus.State == QueryExecutionState.FAILED)
{
throw new Exception("Query Failed to run with Error Message: " + queryExecutionResponse.QueryExecution.Status.StateChangeReason);
}
else if (queryStatus.State == QueryExecutionState.CANCELLED)
{
throw new Exception("Query was cancelled.");
}
else if (queryStatus.State == QueryExecutionState.SUCCEEDED)
{
isQueryStillRunning = false;
}
// Sleep an amount before retrying again.
Console.WriteLine("Current Status is: " + queryStatus.State.Value);
Thread.Sleep(new TimeSpan(0, 0, 1));
}
}
/// <summary>
/// Returns information about a single execution of a query. Each time a query executes,
/// information about the query execution is saved with a unique ID.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetQueryExecution service method.</param>
///
/// <returns>The response from the GetQueryExecution service method, as returned by Athena.</returns>
/// <exception cref="Amazon.Athena.Model.InternalServerException">
/// Indicates a platform issue, which may be due to a transient condition or outage.
/// </exception>
/// <exception cref="Amazon.Athena.Model.InvalidRequestException">
/// Indicates that something is wrong with the input to the request. For example, a required
/// parameter may be missing or out of range.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/athena-2017-05-18/GetQueryExecution">REST API Reference for GetQueryExecution Operation</seealso>
public GetQueryExecutionResponse GetQueryExecution(GetQueryExecutionRequest request)
{
var marshaller = new GetQueryExecutionRequestMarshaller();
var unmarshaller = GetQueryExecutionResponseUnmarshaller.Instance;
return(Invoke <GetQueryExecutionRequest, GetQueryExecutionResponse>(request, marshaller, unmarshaller));
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueryExecution operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueryExecution 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>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/athena-2017-05-18/GetQueryExecution">REST API Reference for GetQueryExecution Operation</seealso>
public virtual Task <GetQueryExecutionResponse> GetQueryExecutionAsync(GetQueryExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = GetQueryExecutionRequestMarshaller.Instance;
var unmarshaller = GetQueryExecutionResponseUnmarshaller.Instance;
return(InvokeAsync <GetQueryExecutionRequest, GetQueryExecutionResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
internal virtual GetQueryExecutionResponse GetQueryExecution(GetQueryExecutionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetQueryExecutionRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetQueryExecutionResponseUnmarshaller.Instance;
return(Invoke <GetQueryExecutionResponse>(request, options));
}
async static Task <List <Dictionary <String, String> > > getQueryExecution(IAmazonAthena client, String id)
{
List <Dictionary <String, String> > items = new List <Dictionary <String, String> >();
GetQueryExecutionResponse results = null;
QueryExecution q = null;
/* Declare query execution request object */
GetQueryExecutionRequest qReq = new GetQueryExecutionRequest()
{
QueryExecutionId = id
};
/* Poll API to determine when the query completed */
do
{
results = await client.GetQueryExecutionAsync(qReq);
q = results.QueryExecution;
await Task.Delay(5000); //Wait for 5sec before polling again
} while (q.Status.State == "RUNNING" || q.Status.State == "QUEUED");
Console.WriteLine("Data Scanned for {0}: {1} Bytes", id, q.Statistics.DataScannedInBytes);
/* Declare query results request object */
GetQueryResultsRequest resReq = new GetQueryResultsRequest()
{
QueryExecutionId = id,
MaxResults = 10
};
GetQueryResultsResponse resResp = null;
/* Page through results and request additional pages if available */
do
{
resResp = await client.GetQueryResultsAsync(resReq);
/* Loop over result set and create a dictionary with column name for key and data for value */
foreach (Row row in resResp.ResultSet.Rows)
{
Dictionary <String, String> dict = new Dictionary <String, String>();
for (var i = 0; i < resResp.ResultSet.ResultSetMetadata.ColumnInfo.Count; i++)
{
dict.Add(resResp.ResultSet.ResultSetMetadata.ColumnInfo[i].Name, row.Data[i].VarCharValue);
}
items.Add(dict);
}
if (resResp.NextToken != null)
{
resReq.NextToken = resResp.NextToken;
}
} while (resResp.NextToken != null);
/* Return List of dictionary per row containing column name and value */
return(items);
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueryExecution operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueryExecution 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>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/athena-2017-05-18/GetQueryExecution">REST API Reference for GetQueryExecution Operation</seealso>
public virtual Task <GetQueryExecutionResponse> GetQueryExecutionAsync(GetQueryExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetQueryExecutionRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetQueryExecutionResponseUnmarshaller.Instance;
return(InvokeAsync <GetQueryExecutionResponse>(request, options, cancellationToken));
}
public async Task <GetQueryResultsRequest> ExecuteQuery(string query) // Task<GetQueryResultsResponse>
{
var startResponse = await amazonAthenaClient.StartQueryExecutionAsync(new StartQueryExecutionRequest()
{
QueryString = query,
ResultConfiguration = new ResultConfiguration()
{
OutputLocation = awsAthenaOptions.DefaultOutputLocation,
}
});
var queryId = startResponse.QueryExecutionId;
GetQueryExecutionRequest getQueryExecutionRequest = new GetQueryExecutionRequest()
{
QueryExecutionId = queryId
};
bool isStillingRunning = true;
while (isStillingRunning)
{
var executionResponse = await amazonAthenaClient.GetQueryExecutionAsync(getQueryExecutionRequest);
var state = executionResponse.QueryExecution.Status.State;
if (state == QueryExecutionState.FAILED)
{
throw new Exception($"Query Failed to run with Error Message: \n{executionResponse.QueryExecution.Status.StateChangeReason}");
}
else if (state == QueryExecutionState.CANCELLED)
{
throw new Exception($"Query was cancelled.");
}
else if (state == QueryExecutionState.SUCCEEDED)
{
isStillingRunning = false;
}
}
return(new GetQueryResultsRequest()
{
QueryExecutionId = queryId
});
//var resultResponse = await amazonAthenaClient.GetQueryResultsAsync(new GetQueryResultsRequest()
//{
// QueryExecutionId = queryId
//});
//return resultResponse;
}
public static async Task <GetQueryResultsResponse> QueryAsyncLight(this AmazonAthenaClient client, StartQueryExecutionRequest request, int timeoutSeconds)
{
var executionResult = await client.StartQueryExecutionAsync(request);
var queryExecutionRequest = new GetQueryExecutionRequest
{
QueryExecutionId = executionResult.QueryExecutionId
};
return(await Task.Run <GetQueryResultsResponse>(async() =>
{
var start = DateTime.Now;
while ((DateTime.Now - start).Seconds < timeoutSeconds)
{
await Task.Delay(1000);
var response = await client.GetQueryExecutionAsync(queryExecutionRequest);
switch (response.QueryExecution.Status.State)
{
case var queued when queued == QueryExecutionState.QUEUED:
case var running when running == QueryExecutionState.RUNNING:
continue;
case var cancelled when cancelled == QueryExecutionState.CANCELLED:
{
throw new AthenaQueryExecutionException($"The query({executionResult.QueryExecutionId}) has been calceled", response);
}
case var failed when failed == QueryExecutionState.FAILED:
{
throw new AthenaQueryExecutionException($"The query({executionResult.QueryExecutionId}) failed", response);
}
case var secceeded when secceeded == QueryExecutionState.SUCCEEDED:
{
var resultRequest = new GetQueryResultsRequest
{
QueryExecutionId = executionResult.QueryExecutionId
};
var result = await client.GetQueryResultsAsync(resultRequest);
return result;
}
default:
throw new AthenaQueryExecutionException($"Unrecognized query({response.QueryExecution.QueryExecutionId}) State", response);
}
}
throw new AthenaQueryExecutionException($"query({executionResult.QueryExecutionId}) Timeout", null);
}));
}
/// <summary>
/// Poll API to determine when the query completed
/// </summary>
public async Task PoolQueryExecutionAsync(string queryExecutionId, int delayMs = 5000)
{
QueryExecution queryExecution = null;
var executingStates = new string[] { QueryExecutionState.RUNNING, QueryExecutionState.QUEUED };
var unsuccessStates = new string[] { QueryExecutionState.CANCELLED, QueryExecutionState.FAILED };
do
{
try
{
_logger.LogDebug($"PoolQueryExecutionAsync for 'queryExecutionId': '{queryExecutionId}'.");
var getQueryExecutionRequest = new GetQueryExecutionRequest()
{
QueryExecutionId = queryExecutionId
};
var client = _amazonAthenaClientFactory.Create();
var getQueryExecutionAsyncResponse = await client.GetQueryExecutionAsync(getQueryExecutionRequest);
getQueryExecutionAsyncResponse.EnsureSuccessStatusCode();
queryExecution = getQueryExecutionAsyncResponse.QueryExecution;
_logger.LogDebug($"PoolQueryExecutionAsync state '{queryExecution.Status.State}', StateChangeReason: '{queryExecution.Status.StateChangeReason}' for 'queryExecutionId': '{queryExecutionId}'.");
if (unsuccessStates.Any(state => queryExecution.Status.State.Equals(state)))
{
throw new Exception($"QueryExecution for 'queryExecutionId': '{queryExecutionId}' failed.",
new Exception($"State '{queryExecution.Status.State}', StateChangeReason: '{queryExecution.Status.StateChangeReason}'."));
}
await Task.Delay(delayMs);
}
catch (InvalidRequestException e)
{
_logger.LogError(e, $"Exception while executing PoolQueryExecutionAsync for 'queryExecutionId': '{queryExecutionId}'.");
}
}while (executingStates.Any(state => queryExecution.Status.State.Equals(state)));
_logger.LogDebug($"Data Scanned for '{queryExecutionId}': '{queryExecution.Statistics.DataScannedInBytes}' Bytes.");
}
public async Task <List <T> > TryObtainQueryResultById <T>(string queryId, int skip = 1) where T : class, new()
{
GetQueryExecutionRequest getQueryExecutionRequest = new GetQueryExecutionRequest()
{
QueryExecutionId = queryId
};
bool isStillingRunning = true;
var executionResponse = await amazonAthenaClient.GetQueryExecutionAsync(getQueryExecutionRequest);
var state = executionResponse.QueryExecution.Status.State;
if (state == QueryExecutionState.FAILED)
{
throw new Exception($"Query Failed to run with Error Message: \n{executionResponse.QueryExecution.Status.StateChangeReason}");
}
else if (state == QueryExecutionState.CANCELLED)
{
throw new Exception($"Query was cancelled.");
}
else if (state == QueryExecutionState.SUCCEEDED)
{
isStillingRunning = false;
}
if (isStillingRunning)
{
return(null);
}
var resultResponse = await amazonAthenaClient.GetQueryResultsAsync(new GetQueryResultsRequest()
{
QueryExecutionId = queryId
});
return(resultResponse.ReadRows <T>(skip));
}
public string ExecuteQuery(string query, ref QueryStageStatistics queryStats)
{
#region Setup
QueryExecutionContext queryExecContext = new QueryExecutionContext()
{
Database = this.DataBase
};
ResultConfiguration resultConfig = new ResultConfiguration()
{
OutputLocation = this.OutputLocation
};
StartQueryExecutionRequest startQueryExecRequest = new StartQueryExecutionRequest()
{
QueryExecutionContext = queryExecContext,
QueryString = query,
ResultConfiguration = resultConfig
};
#endregion
var watch = new Stopwatch();
#region Query Execution
//Start Query execution and wait till start command has completed
var startQueryExecResult = _athenaClient.StartQueryExecutionAsync(startQueryExecRequest);
//Start measurement
watch.Start();
while (!startQueryExecResult.IsCompleted)
{
Thread.Sleep(100);
Console.Write($"\r START {watch.Elapsed}");
}
if (startQueryExecResult.Exception != null)
{
throw new Exception("Query Execution", startQueryExecResult.Exception);
}
if (startQueryExecResult.IsCanceled)
{
return("- Cancelled -");
}
//Query if query execution has finished
GetQueryExecutionRequest getQueryExecRequest = new GetQueryExecutionRequest()
{
QueryExecutionId = startQueryExecResult.Result.QueryExecutionId
};
Task <Amazon.Athena.Model.GetQueryExecutionResponse> getQueryExecResult = null;
bool isQueryRunning = true;
while (isQueryRunning)
{
getQueryExecResult = _athenaClient.GetQueryExecutionAsync(getQueryExecRequest);
var state = getQueryExecResult.Result.QueryExecution.Status.State;
if (state == Amazon.Athena.QueryExecutionState.FAILED)
{
throw new Exception("Query Execution", getQueryExecResult.Exception);
}
else if (state == Amazon.Athena.QueryExecutionState.CANCELLED)
{
return("- Canceled -");
}
else if (state == Amazon.Athena.QueryExecutionState.SUCCEEDED)
{
isQueryRunning = false;
queryStats.QueryExecutionTime = watch.Elapsed;
}
else
{
Thread.Sleep(100);
Console.Write($"\r EXEC {watch.Elapsed}");
}
}
queryStats.EngineExecutionTimeInMillis = getQueryExecResult.Result.QueryExecution.Statistics.EngineExecutionTimeInMillis;
queryStats.DataScannedInBytes = getQueryExecResult.Result.QueryExecution.Statistics.DataScannedInBytes;
#endregion
watch.Restart();
#region Get Query Result
GetQueryResultsRequest getQueryResultRequest = new GetQueryResultsRequest()
{
QueryExecutionId = getQueryExecResult.Result.QueryExecution.QueryExecutionId
};
var getQueryResultsResult = _athenaClient.GetQueryResultsAsync(getQueryResultRequest);
//No data process is taken account. Only take meassurements.
long contentSize = 0, totalRows = 0;
while (true)
{
while (!getQueryResultsResult.IsCompleted)
{
Thread.Sleep(100);
Console.Write($"\r FETCH {watch.Elapsed}");
}
if (getQueryResultsResult.Exception != null)
{
throw new Exception("Retrieving Query Rows", getQueryResultsResult.Exception);
}
if (getQueryResultsResult.IsCanceled)
{
return("- Canceled -");
}
//while(getQueryResultsResult.Status == System.Threading.Tasks.TaskStatus.Running)
//{
// Thread.Sleep(100);
// Console.Write(".");
//}
totalRows += getQueryResultsResult.Result.ResultSet.Rows.Count;
if (getQueryResultsResult.Result.NextToken == null || totalRows >= SampleContext.MAX_FETCHED_RECORDS)
{
queryStats.DataFetchingTime = watch.Elapsed;
contentSize += getQueryResultsResult.Result.ContentLength;
break;
}
getQueryResultsResult = _athenaClient.GetQueryResultsAsync(new GetQueryResultsRequest()
{
QueryExecutionId = getQueryResultRequest.QueryExecutionId,
NextToken = getQueryResultRequest.NextToken
}
);
}
#endregion
return($"{contentSize} bytes took {queryStats.QueryExecutionTime} executing query and {queryStats.DataFetchingTime} fetching first {SampleContext.MAX_FETCHED_RECORDS} records.");
}
public async Task <List <Dictionary <string, string> > > GetQueryExecution(IAmazonAthena client, string id)
{
List <Dictionary <String, String> > items = new List <Dictionary <String, String> >();
GetQueryExecutionResponse results = null;
QueryExecution queryExecution = null;
/* Declare query execution request object */
GetQueryExecutionRequest queryExReq = new GetQueryExecutionRequest()
{
QueryExecutionId = id
};
/* Poll API to determine when the query completed */
do
{
try
{
results = await client.GetQueryExecutionAsync(queryExReq);
queryExecution = results.QueryExecution;
_logger.LogInformation("Status: {0}... {1}", queryExecution.Status.State, queryExecution.Status.StateChangeReason);
await Task.Delay(5000); //Wait for 5sec before polling again
}
catch (InvalidRequestException e)
{
_logger.LogInformation("GetQueryExec Error: {0}", e.Message);
}
} while (queryExecution.Status.State == "RUNNING" || queryExecution.Status.State == "QUEUED");
_logger.LogInformation("Data Scanned for {0}: {1} Bytes", id, queryExecution.Statistics.DataScannedInBytes);
/* Declare query results request object */
GetQueryResultsRequest queryResultRequest = new GetQueryResultsRequest()
{
QueryExecutionId = id,
MaxResults = 10
};
GetQueryResultsResponse queryResult = null;
/* Page through results and request additional pages if available */
do
{
queryResult = await client.GetQueryResultsAsync(queryResultRequest);
/* Loop over result set and create a dictionary with column name for key and data for value */
foreach (Row row in queryResult.ResultSet.Rows)
{
Dictionary <String, String> dict = new Dictionary <String, String>();
for (var i = 0; i < queryResult.ResultSet.ResultSetMetadata.ColumnInfo.Count; i++)
{
dict.Add(queryResult.ResultSet.ResultSetMetadata.ColumnInfo[i].Name, row.Data[i].VarCharValue);
}
items.Add(dict);
}
if (queryResult.NextToken != null)
{
queryResultRequest.NextToken = queryResult.NextToken;
}
} while (queryResult.NextToken != null);
/* Return List of dictionary per row containing column name and value */
return(items);
}
public APIGatewayProxyResponse Get(APIGatewayProxyRequest request, ILambdaContext context)
{
context.Logger.LogLine("Get Request\n");
using (var client = new AmazonAthenaClient(Amazon.RegionEndpoint.USEast1))
{
String date = JsonConvert.DeserializeObject <String>(request?.Body);
QueryExecutionContext qContext = new QueryExecutionContext();
qContext.Database = ATHENA_DB;
ResultConfiguration resConf = new ResultConfiguration();
resConf.OutputLocation = ATHENA_TEMP_PATH;
Console.WriteLine("Created Athena Client");
run(client, qContext, resConf, date).Wait();
}
async Task run(IAmazonAthena client, QueryExecutionContext qContext, ResultConfiguration resConf, String date)
{
StartQueryExecutionRequest qReq = new StartQueryExecutionRequest()
{
QueryString = "SELECT emp_name FROM emp_table WHERE date = " + date + "limit 10;",
QueryExecutionContext = qContext,
ResultConfiguration = resConf
};
try
{
StartQueryExecutionResponse qRes = await client.StartQueryExecutionAsync(qReq);
List <Dictionary <String, String> > items = await getQueryExecution(client, qRes.QueryExecutionId);
foreach (var item in items)
{
foreach (KeyValuePair <String, String> pair in item)
{
Console.WriteLine("Col: {0}", pair.Key);
Console.WriteLine("Val: {0}", pair.Value);
}
}
}
catch (InvalidRequestException e)
{
Console.WriteLine("Run Error: {0}", e.Message);
}
}
async Task <List <Dictionary <String, String> > > getQueryExecution(IAmazonAthena client, String id)
{
List <Dictionary <String, String> > items = new List <Dictionary <String, String> >();
GetQueryExecutionResponse results = null;
QueryExecution q = null;
GetQueryExecutionRequest qReq = new GetQueryExecutionRequest()
{
QueryExecutionId = id
};
do
{
try
{
results = await client.GetQueryExecutionAsync(qReq);
q = results.QueryExecution;
Console.WriteLine("Status: {0}... {1}", q.Status.State, q.Status.StateChangeReason);
await Task.Delay(5000);
}
catch (InvalidRequestException e)
{
Console.WriteLine("GetQueryExec Error: {0}", e.Message);
}
} while (q.Status.State == "RUNNING" || q.Status.State == "QUEUED");
Console.WriteLine("Data Scanned for {0}: {1} Bytes", id, q.Statistics.DataScannedInBytes);
GetQueryResultsRequest resReq = new GetQueryResultsRequest()
{
QueryExecutionId = id,
MaxResults = 10
};
GetQueryResultsResponse resResp = null;
do
{
resResp = await client.GetQueryResultsAsync(resReq);
foreach (Row row in resResp.ResultSet.Rows)
{
Dictionary <String, String> dict = new Dictionary <String, String>();
for (var i = 0; i < resResp.ResultSet.ResultSetMetadata.ColumnInfo.Count; i++)
{
dict.Add(resResp.ResultSet.ResultSetMetadata.ColumnInfo[i].Name, row.Data[i].VarCharValue);
}
items.Add(dict);
}
if (resResp.NextToken != null)
{
resReq.NextToken = resResp.NextToken;
}
} while (resResp.NextToken != null);
return(items);
}
var response = new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = "GET Method Executed",
Headers = new Dictionary <string,
string> {
{ "Content-Type", "application/json" }
}
};
return(response);
}
async static Task <List <Dictionary <String, String> > > getQueryExecution(IAmazonAthena client, String id)
{
List <Dictionary <String, String> > items = new List <Dictionary <String, String> >();
GetQueryExecutionResponse results = null;
QueryExecution q = null;
/* Declare query execution request object */
GetQueryExecutionRequest qReq = new GetQueryExecutionRequest()
{
QueryExecutionId = id
};
/* Poll API to determine when the query completed */
do
{
List <Dictionary <string, string> > lists = new List <Dictionary <string, string> >();
try
{
results = await client.GetQueryExecutionAsync(qReq);
if (results == null)
{
Dictionary <string, string> dic1 = new Dictionary <string, string>();
dic1.Add("error", "results is null");
lists.Add(dic1);
return(lists);
}
q = results.QueryExecution;
if (q == null)
{
Dictionary <string, string> dic3 = new Dictionary <string, string>();
dic3.Add("error", "q is null");
lists.Add(dic3);
return(lists);
}
Console.WriteLine("Status: {0}... {1}", q.Status.State, q.Status.StateChangeReason);
await Task.Delay(5000); //Wait for 5sec before polling again
}
catch (InvalidRequestException e)
{
Dictionary <string, string> dic2 = new Dictionary <string, string>();
dic2.Add("error", "exception : " + " (Run method) " + " : " + e.Message);
lists.Add(dic2);
Console.WriteLine("GetQueryExec Error: {0}", e.Message);
return(lists);
}
} while (q.Status.State == "RUNNING" || q.Status.State == "QUEUED");
Console.WriteLine("Data Scanned for {0}: {1} Bytes", id, q.Statistics.DataScannedInBytes);
/* Declare query results request object */
GetQueryResultsRequest resReq = new GetQueryResultsRequest()
{
QueryExecutionId = id,
MaxResults = 20
};
GetQueryResultsResponse resResp = null;
/* Page through results and request additional pages if available */
Dictionary <String, String> dic = new Dictionary <String, String>();
List <Dictionary <String, String> > l = new List <Dictionary <String, String> >();
do
{
resResp = await client.GetQueryResultsAsync(resReq);
//l.Add(dict);
/* Loop over result set and create a dictionary with column name for key and data for value */
foreach (Row row in resResp.ResultSet.Rows)
{
Dictionary <String, String> dict = new Dictionary <String, String>();
for (var i = 0; i < resResp.ResultSet.ResultSetMetadata.ColumnInfo.Count; i++)
{
dict.Add(resResp.ResultSet.ResultSetMetadata.ColumnInfo[i].Name, row.Data[i].VarCharValue);
}
items.Add(dict);
}
if (resResp.NextToken != null)
{
resReq.NextToken = resResp.NextToken;
}
} while (resResp.NextToken != null);
if (items == null)
{
dic.Add("error", "items are null here");
l.Add(dic);
return(l);
}
/* Return List of dictionary per row containing column name and value */
return(items);
}
