Esempio n. 1
0
        internal static async Task ExecuteQuery(string query)
        {
            // create a temporary "workspace" file
            using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
                // create the client helper which wraps the client driver objects
                using (ClientHelper testHelper = new ClientHelper())
                {
                    // connnection details
                    ConnectParams connectParams = new ConnectParams();
                    connectParams.Connection                    = new ConnectionDetails();
                    connectParams.Connection.ServerName         = "localhost";
                    connectParams.Connection.DatabaseName       = "master";
                    connectParams.Connection.AuthenticationType = "Integrated";

                    // connect to the database
                    await testHelper.Connect(queryTempFile.FilePath, connectParams);

                    // execute the query
                    QueryCompleteParams queryComplete =
                        await testHelper.RunQuery(queryTempFile.FilePath, query);

                    if (queryComplete.BatchSummaries != null && queryComplete.BatchSummaries.Length > 0)
                    {
                        var batch = queryComplete.BatchSummaries[0];
                        if (batch.ResultSetSummaries != null && batch.ResultSetSummaries.Length > 0)
                        {
                            var resultSet = batch.ResultSetSummaries[0];

                            // retrive the results
                            SubsetResult querySubset = await testHelper.ExecuteSubset(
                                queryTempFile.FilePath, batch.Id,
                                resultSet.Id, 0, (int)resultSet.RowCount);

                            // print the header
                            foreach (var column in resultSet.ColumnInfo)
                            {
                                Console.Write(column.ColumnName + ", ");
                            }
                            Console.Write(Environment.NewLine);

                            // print the rows
                            foreach (var row in querySubset.ResultSubset.Rows)
                            {
                                for (int i = 0; i < resultSet.ColumnInfo.Length; ++i)
                                {
                                    Console.Write(row[i].DisplayValue + ", ");
                                }
                                Console.Write(Environment.NewLine);
                            }
                        }
                    }

                    // close database connection
                    await testHelper.Disconnect(queryTempFile.FilePath);
                }
        }
        /// <summary>
        /// Handles a request to get a subset of the results of this query
        /// </summary>
        internal async Task HandleResultSubsetRequest(SubsetParams subsetParams,
                                                      RequestContext <SubsetResult> requestContext)
        {
            try
            {
                // Attempt to load the query
                Query query;
                if (!ActiveQueries.TryGetValue(subsetParams.OwnerUri, out query))
                {
                    await requestContext.SendResult(new SubsetResult
                    {
                        Message = SR.QueryServiceRequestsNoQuery
                    });

                    return;
                }

                // Retrieve the requested subset and return it
                var result = new SubsetResult
                {
                    Message      = null,
                    ResultSubset = await query.GetSubset(subsetParams.BatchIndex,
                                                         subsetParams.ResultSetIndex, subsetParams.RowsStartIndex, subsetParams.RowsCount)
                };
                await requestContext.SendResult(result);
            }
            catch (InvalidOperationException ioe)
            {
                // Return the error as a result
                await requestContext.SendResult(new SubsetResult
                {
                    Message = ioe.Message
                });
            }
            catch (ArgumentOutOfRangeException aoore)
            {
                // Return the error as a result
                await requestContext.SendResult(new SubsetResult
                {
                    Message = aoore.Message
                });
            }
            catch (Exception e)
            {
                // This was unexpected, so send back as error
                await requestContext.SendError(e.Message);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Handles a request to get a subset of the results of this query
        /// </summary>
        internal async Task HandleResultSubsetRequest(SubsetParams subsetParams,
                                                      RequestContext <SubsetResult> requestContext)
        {
            try
            {
                ResultSetSubset subset = await InterServiceResultSubset(subsetParams);

                var result = new SubsetResult
                {
                    ResultSubset = subset
                };
                await requestContext.SendResult(result);
            }
            catch (Exception e)
            {
                // This was unexpected, so send back as error
                await requestContext.SendError(e.Message);
            }
        }
Esempio n. 4
0
        public static void saveResultsToFile(string file, IEnumerable <SubsetResult> results)
        {
            var stream = File.Open(file, FileMode.Create, FileAccess.Write);
            var sw     = new StreamWriter(stream);

            sw.WriteLine(SubsetResult.getCSVHead());

            int i = 0;

            foreach (var result in results)
            {
                foreach (var row in result.getCSVData(i))
                {
                    sw.WriteLine(row);
                }
                i++;
            }
            sw.Close();
        }
Esempio n. 5
0
        /// <summary>
        /// Handles a request to get a subset of the results of this query
        /// </summary>
        internal async Task HandleResultSubsetRequest(SubsetParams subsetParams,
                                                      RequestContext <SubsetResult> requestContext)
        {
            try
            {
                ResultSetSubset subset = await InterServiceResultSubset(subsetParams);

                var result = new SubsetResult
                {
                    ResultSubset = subset
                };
                await requestContext.SendResult(result);

                Logger.Write(TraceEventType.Stop, $"Done Handler for Subset request with for Query:'{subsetParams.OwnerUri}', Batch:'{subsetParams.BatchIndex}', ResultSetIndex:'{subsetParams.ResultSetIndex}', RowsStartIndex'{subsetParams.RowsStartIndex}', Requested RowsCount:'{subsetParams.RowsCount}'\r\n\t\t with subset response of:[ RowCount:'{subset.RowCount}', Rows array of length:'{subset.Rows.Length}']");
            }
            catch (Exception e)
            {
                // This was unexpected, so send back as error
                await requestContext.SendError(e.Message);
            }
        }
Esempio n. 6
0
 public static string getCSVHead()
 {
     return(Configuration.getCSVHeaders() + ";CrossValidationRecognitionTime;" + SubsetResult.getCSVHead());
 }
Esempio n. 7
0
 public static string getCSVHead()
 {
     return("CrossValidationRecognitionTime;" + SubsetResult.getCSVHead());
 }