コード例 #1
0
        /// <summary>
        /// Asynchronously but eagerly fetches a set of rows, up to the specified count, providing a page of results with a next page token
        /// if more results are available. This is typically used within web applications, where the next page token
        /// is propagated to the client along with the results, so that the next page can be retrieved in another request.
        /// </summary>
        /// <param name="pageSize">The maximum number of rows to retrieve. Must be positive.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task representing the asynchronous operation. When complete, the result is
        /// an in-memory result set of at most the given number of rows.</returns>
        public async Task <BigQueryPage> ReadPageAsync(int pageSize, CancellationToken cancellationToken = default)
        {
            GaxPreconditions.CheckArgumentRange(pageSize, nameof(pageSize), 1, int.MaxValue);
            GetQueryResultsOptions clonedOptions = _options?.Clone() ?? new GetQueryResultsOptions();
            List <BigQueryRow>     rows          = new List <BigQueryRow>(pageSize);

            // Work out whether to use the response we've already got, or create a new one.
            GetQueryResultsResponse response = _response;

            if (response.Rows?.Count > pageSize)
            {
                // Oops. Do it again from scratch, with a useful page size.
                clonedOptions.PageSize = pageSize;
                response = await _client.GetRawQueryResultsAsync(JobReference, clonedOptions, timeoutBase : null, cancellationToken).ConfigureAwait(false);
            }
            // First add the rows from the existing response.
            rows.AddRange(ConvertResponseRows(response));
            string pageToken = response.PageToken;

            clonedOptions.StartIndex = null;

            // Now keep going until we've filled the result set or know there's no more data.
            while (rows.Count < pageSize && pageToken != null)
            {
                clonedOptions.PageToken = pageToken;
                clonedOptions.PageSize  = pageSize - rows.Count;
                var nextResponse = await _client.GetRawQueryResultsAsync(JobReference, clonedOptions, timeoutBase : null, cancellationToken).ConfigureAwait(false);

                rows.AddRange(ConvertResponseRows(nextResponse));
                pageToken = nextResponse.PageToken;
            }
            return(new BigQueryPage(rows, Schema, JobReference, TableReference, pageToken));
        }
コード例 #2
0
 internal BigQueryResults(BigQueryClient client, GetQueryResultsResponse response, TableReference tableReference, ListRowsOptions options)
 {
     _client        = GaxPreconditions.CheckNotNull(client, nameof(client));
     _response      = GaxPreconditions.CheckNotNull(response, nameof(response));
     TableReference = GaxPreconditions.CheckNotNull(tableReference, nameof(tableReference));
     _options       = options;
 }
コード例 #3
0
 internal BigqueryResult(BigqueryClient client, GetQueryResultsResponse firstResult, Func<GetQueryResultsRequest> requestProvider)
 {
     _client = client;
     Schema = firstResult.Schema;
     var firstRows = firstResult.Rows ?? new TableRow[0];
     Rows = firstRows.Concat(GetRemainingRows(requestProvider, firstResult.PageToken)).Select(row => new Row(this, row));
 }
コード例 #4
0
        public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
        {
            AmazonAthenaConfig config = new AmazonAthenaConfig();

            config.RegionEndpoint = region;
            ConfigureClient(config);
            AmazonAthenaClient client = new AmazonAthenaClient(creds, config);

            GetQueryResultsResponse resp = new GetQueryResultsResponse();

            do
            {
                GetQueryResultsRequest req = new GetQueryResultsRequest
                {
                    NextToken = resp.NextToken
                    ,
                    MaxResults = maxItems
                };

                resp = client.GetQueryResults(req);
                CheckError(resp.HttpStatusCode, "200");

                foreach (var obj in resp.UpdateCount)
                {
                    AddObject(obj);
                }

                foreach (var obj in resp.ResultSet)
                {
                    AddObject(obj);
                }
            }while (!string.IsNullOrEmpty(resp.NextToken));
        }
コード例 #5
0
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            GetQueryResultsResponse response = new GetQueryResultsResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("results", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller <List <ResultField>, ListUnmarshaller <ResultField, ResultFieldUnmarshaller> >(new ListUnmarshaller <ResultField, ResultFieldUnmarshaller>(ResultFieldUnmarshaller.Instance));
                    response.Results = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("statistics", targetDepth))
                {
                    var unmarshaller = QueryStatisticsUnmarshaller.Instance;
                    response.Statistics = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("status", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.Status = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return(response);
        }
コード例 #6
0
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            GetQueryResultsResponse response = new GetQueryResultsResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("NextToken", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.NextToken = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("ResultSet", targetDepth))
                {
                    var unmarshaller = ResultSetUnmarshaller.Instance;
                    response.ResultSet = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("UpdateCount", targetDepth))
                {
                    var unmarshaller = LongUnmarshaller.Instance;
                    response.UpdateCount = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return(response);
        }
コード例 #7
0
 /// <summary>
 /// Constructs a new set of results.
 /// </summary>
 /// <remarks>
 /// This is public to allow tests to construct instances for production code to consume;
 /// production code should not normally construct instances itself.
 /// </remarks>
 /// <param name="client">The client to use for further operations. Must not be null.</param>
 /// <param name="response">The response to a GetQueryResults API call. Must not be null.</param>
 /// <param name="tableReference">A reference to the table containing the results.
 /// May be null. (For example, script queries don't store results in tables.)</param>
 /// <param name="options">Options to use when fetching results. May be null.</param>
 public BigQueryResults(BigQueryClient client, GetQueryResultsResponse response, TableReference tableReference, GetQueryResultsOptions options)
 {
     _client        = GaxPreconditions.CheckNotNull(client, nameof(client));
     _response      = GaxPreconditions.CheckNotNull(response, nameof(response));
     TableReference = tableReference;
     _options       = options;
     _fieldNames    = response.Schema?.IndexFieldNames();
 }
コード例 #8
0
ファイル: Function.cs プロジェクト: honeyo7/AwsloggerSolution
        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);
        }
コード例 #9
0
 private QueryResponse(BigQueryContext context, string query, TimeSpan executionTime,
                       GetQueryResultsResponse queryResponse, bool isDynamic, IRowsParser rowsParser)
     : this(
         context, query, executionTime, isDynamic, rowsParser, queryResponse.Rows, queryResponse.Schema,
         queryResponse.CacheHit, queryResponse.ETag, queryResponse.Kind,
         queryResponse.PageToken, queryResponse.TotalBytesProcessed, queryResponse.TotalRows,
         queryResponse.JobComplete, queryResponse.JobReference)
 {
 }
コード例 #10
0
        public static List <List <object> > ReadData(this GetQueryResultsResponse getQueryResultsResponse, int skip = 1)
        {
            var columnInfos = getQueryResultsResponse.ResultSet.ResultSetMetadata.ColumnInfo;
            var results     = new List <List <object> >();

            foreach (var row in getQueryResultsResponse.ResultSet.Rows.Skip(skip))
            {
                results.Add(row.ReadRowAsObjects(columnInfos));
            }
            return(results);
        }
コード例 #11
0
        public static Dictionary <string, string> ToSchemaDictionary(this GetQueryResultsResponse getQueryResultsResponse)
        {
            var columnInfos = getQueryResultsResponse.ResultSet.ResultSetMetadata.ColumnInfo;
            var results     = new Dictionary <string, string>();

            foreach (var column in columnInfos)
            {
                results.Add(column.Name, column.MapCSharpType());
            }
            return(results);
        }
コード例 #12
0
        // [END build_service]

        public IList <TableRow> ExecuteQuery(string querySql, BigqueryService bigquery, string projectId)
        {
            var request = new Google.Apis.Bigquery.v2.JobsResource.QueryRequest(
                bigquery, new Google.Apis.Bigquery.v2.Data.QueryRequest()
            {
                Query = querySql,
            }, projectId);
            var query = request.Execute();
            GetQueryResultsResponse queryResult = bigquery.Jobs.GetQueryResults(
                projectId, query.JobReference.JobId).Execute();

            return(queryResult.Rows);
        }
コード例 #13
0
        public static List <T> ReadRows <T>(this GetQueryResultsResponse getQueryResultsResponse, int skip = 1) where T : class, new()
        {
            var columnInfos   = getQueryResultsResponse.ResultSet.ResultSetMetadata.ColumnInfo;
            var type          = typeof(T);
            var propertyInfos = type.GetProperties().ToDictionary(p => p.Name.ToLower(), p => p);

            var results = new List <T>();

            foreach (var row in getQueryResultsResponse.ResultSet.Rows.Skip(skip))
            {
                results.Add(row.ReadRowAs <T>(columnInfos, propertyInfos));
            }
            return(results);
        }
コード例 #14
0
        /// <summary>
        /// this is the code generation tool to build C# type
        /// </summary>
        /// <param name="getQueryResultsResponse"></param>
        /// <returns></returns>
        public static string ToCSharpType(this GetQueryResultsResponse getQueryResultsResponse)
        {
            var columnInfos = getQueryResultsResponse.ResultSet.ResultSetMetadata.ColumnInfo;

            StringBuilder stb = new StringBuilder();

            stb.AppendLine($"public class QueryResult");
            stb.AppendLine($"{{");
            foreach (var column in columnInfos)
            {
                stb.AppendLine($"\tpublic {column.MapCSharpType()} {column.Name} {{ get; set; }}");
            }
            stb.AppendLine("}}");
            return(stb.ToString());
        }
コード例 #15
0
        public static List <FieldMapping> ToFieldMapping(this GetQueryResultsResponse getQueryResultsResponse)
        {
            var columnInfos = getQueryResultsResponse.ResultSet.ResultSetMetadata.ColumnInfo;
            var results     = new List <FieldMapping>();

            foreach (var column in columnInfos)
            {
                results.Add(new FieldMapping()
                {
                    SourceFieldName = column.Name,
                    MappedName      = column.Name,
                    MappedType      = column.ToAthenaType()
                });
            }
            return(results);
        }
コード例 #16
0
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            GetQueryResultsResponse response = new GetQueryResultsResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("ErrorMessage", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.ErrorMessage = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("NextToken", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.NextToken = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("QueryResultRows", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller <List <Dictionary <string, string> >, ListUnmarshaller <Dictionary <string, string>, DictionaryUnmarshaller <string, string, StringUnmarshaller, StringUnmarshaller> > >(new ListUnmarshaller <Dictionary <string, string>, DictionaryUnmarshaller <string, string, StringUnmarshaller, StringUnmarshaller> >(new DictionaryUnmarshaller <string, string, StringUnmarshaller, StringUnmarshaller>(StringUnmarshaller.Instance, StringUnmarshaller.Instance)));
                    response.QueryResultRows = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("QueryStatistics", targetDepth))
                {
                    var unmarshaller = QueryStatisticsUnmarshaller.Instance;
                    response.QueryStatistics = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("QueryStatus", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.QueryStatus = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return(response);
        }
コード例 #17
0
        public async Task <List <Dictionary <string, string> > > GetQueryResultsAsync(string queryExecutionId)
        {
            var items = new List <Dictionary <string, string> >();

            var getQueryResultsRequest = new GetQueryResultsRequest()
            {
                QueryExecutionId = queryExecutionId,
                MaxResults       = 1000
            };

            var client = _amazonAthenaClientFactory.Create();
            GetQueryResultsResponse getQueryResultsResponse = null;

            /* Page through results and request additional pages if available */
            do
            {
                getQueryResultsResponse = await client.GetQueryResultsAsync(getQueryResultsRequest);

                getQueryResultsResponse.EnsureSuccessStatusCode();
                /* Loop over result set and create a dictionary with column name for key and data for value */
                foreach (Row row in getQueryResultsResponse.ResultSet.Rows)
                {
                    var dict = new Dictionary <string, string>();
                    for (var i = 0; i < getQueryResultsResponse.ResultSet.ResultSetMetadata.ColumnInfo.Count; i++)
                    {
                        dict.Add(getQueryResultsResponse.ResultSet.ResultSetMetadata.ColumnInfo[i].Name, row.Data[i].VarCharValue);
                    }

                    items.Add(dict);
                }

                if (getQueryResultsResponse.NextToken != null)
                {
                    getQueryResultsRequest.NextToken = getQueryResultsResponse.NextToken;
                }
            }while (getQueryResultsResponse.NextToken != null);

            return(items);
        }
        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);
        }
コード例 #19
0
 internal BigQueryResults(BigQueryClient client, GetQueryResultsResponse response, GetQueryResultsOptions options)
 {
     _client   = GaxPreconditions.CheckNotNull(client, nameof(client));
     _response = GaxPreconditions.CheckNotNull(response, nameof(response));
     _options  = options;
 }
コード例 #20
0
        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);
        }
コード例 #21
0
 public BigQueryResults(BigQueryClient client, GetQueryResultsResponse response, TableReference tableReference, ListRowsOptions options)
     : this(client, response, tableReference, options?.ToGetQueryResultsOptions())
 {
 }
コード例 #22
0
        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);
        }