public async Task RunQueryAsync2()
{
// Snippet: RunQueryAsync(string,PartitionId,ReadOptions,GqlQuery,CallSettings)
// Additional: RunQueryAsync(string,PartitionId,ReadOptions,GqlQuery,CancellationToken)
// Create client
DatastoreClient datastoreClient = await DatastoreClient.CreateAsync();
// Initialize request argument(s)
string projectId = "";
PartitionId partitionId = new PartitionId();
ReadOptions readOptions = new ReadOptions();
GqlQuery gqlQuery = new GqlQuery();
// Make the request
RunQueryResponse response = await datastoreClient.RunQueryAsync(projectId, partitionId, readOptions, gqlQuery);
// End snippet
}
/// <inheritdoc/>
public override AsyncLazyDatastoreQuery RunQueryLazilyAsync(
GqlQuery gqlQuery,
ReadConsistency?readConsistency = null,
CallSettings callSettings = null)
{
GaxPreconditions.CheckNotNull(gqlQuery, nameof(gqlQuery));
var request = new RunQueryRequest
{
ProjectId = ProjectId,
PartitionId = _partitionId,
GqlQuery = gqlQuery,
ReadOptions = GetReadOptions(readConsistency)
};
var streamer = new QueryStreamer(request, Client.RunQueryApiCall, callSettings);
return(new AsyncLazyDatastoreQuery(streamer.Async()));
}
protected override void ProcessRecord()
{
base.ProcessRecord();
var db = DatastoreDb.Create(Project);
var query = new GqlQuery
{
AllowLiterals = AllowLiterals.ToBool(),
QueryString = Query
};
var results = db.RunQuery(query);
foreach (var ent in results.Entities)
{
WriteObject(ent);
}
}
public async Task <List <TransitStop>?> GetStopsByBoundingRadius(float lat, float lon, int radiusMeters, CancellationToken token)
{
GqlQuery query = new GqlQuery(ApiGqlMembers.stopsByRadius)
.WithParameters(
new GqlParameter(ApiGqlMembers.lat, lat),
new GqlParameter(ApiGqlMembers.lon, lon),
new GqlParameter(ApiGqlMembers.radius, radiusMeters)
)
.WithReturnValues(
new GqlReturnValue(ApiGqlMembers.edges,
new GqlReturnValue(ApiGqlMembers.node,
new GqlReturnValue(ApiGqlMembers.stop,
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.name),
new GqlReturnValue(ApiGqlMembers.code),
new GqlReturnValue(ApiGqlMembers.lat),
new GqlReturnValue(ApiGqlMembers.lon),
new GqlReturnValue(ApiGqlMembers.patterns,
new GqlReturnValue(ApiGqlMembers.name),
new GqlReturnValue(ApiGqlMembers.route,
new GqlReturnValue(ApiGqlMembers.shortName),
new GqlReturnValue(ApiGqlMembers.longName)
)
)
)
)
)
);
ApiStopsByRadius?response = await GetGraphQL <ApiStopsByRadius>(query, token).ConfigureAwait(false);
if (response == null || response?.StopsByRadius?.Edges?.Any() != true)
{
return(null);
}
return(response?.StopsByRadius?.Edges?.Select(x => new TransitStop
{
GtfsId = x.Node.Stop.GtfsId,
Coords = BasicGeopositionExtensions.Create(0.0, x.Node.Stop.Lat, x.Node.Stop.Lon),
Code = x.Node.Stop.Code,
Name = x.Node.Stop.Name,
Id = Guid.NewGuid()
}).ToList());
}
public async Task WhenAlbumsFieldIsIncluded_ThenAlbumsAreReturned(
string query,
Dictionary <string, object> variables)
{
var gqlQuery = new GqlQuery
{
Query = query,
Variables = variables
};
var result = await RunQueryAsync(gqlQuery);
var artist = (Dictionary <string, object>)result["artist"];
//because static typing is such a helpful thing and everyone should use it everywhere!
var albums = ((object[])artist["albums"]);
Assert.NotNull(artist["albums"]);
Assert.Equal(albums.Length, 2);
}
/// <summary>
/// Query for entities.
/// </summary>
/// <param name="project_id">Project ID against which to make the request.</param>
/// <param name="partition_id">
/// Entities are partitioned into subsets, identified by a partition ID.
/// Queries are scoped to a single partition.
/// This partition ID is normalized with the standard default context
/// partition ID.
/// </param>
/// <param name="read_options">The options for this query.</param>
/// <param name="gql_query">The GQL query to run.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>The RPC response.</returns>
public override RunQueryResponse RunQuery(
string projectId,
PartitionId partitionId,
ReadOptions readOptions,
GqlQuery gqlQuery,
CallSettings callSettings = null)
{
RunQueryRequest request = new RunQueryRequest
{
ProjectId = projectId,
PartitionId = partitionId,
ReadOptions = readOptions,
GqlQuery = gqlQuery,
};
return(GrpcClient.RunQuery(
request,
_clientHelper.BuildCallOptions(null, callSettings)));
}
public async Task <List <TransitStopArrivalDeparture>?> GetUpcomingStopArrivalsAndDepartures(string stopId, CancellationToken token)
{
GqlQuery query = new GqlQuery(ApiGqlMembers.stop)
.WithParameters(
new GqlParameter(ApiGqlMembers.id, stopId)
)
.WithReturnValues(
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.name),
new GqlInlineMethodReturnValue(ApiGqlMembers.stoptimesWithoutPatterns, new List <GqlParameter> {
new GqlParameter(ApiGqlMembers.numberOfDepartures, 10)
},
new GqlReturnValue(ApiGqlMembers.trip,
new GqlReturnValue(ApiGqlMembers.route,
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.shortName),
new GqlReturnValue(ApiGqlMembers.longName)
)
),
new GqlReturnValue(ApiGqlMembers.realtimeState),
new GqlReturnValue(ApiGqlMembers.arrivalDelay),
new GqlReturnValue(ApiGqlMembers.scheduledArrival),
new GqlReturnValue(ApiGqlMembers.scheduledDeparture),
new GqlReturnValue(ApiGqlMembers.realtimeArrival),
new GqlReturnValue(ApiGqlMembers.realtimeDeparture),
new GqlReturnValue(ApiGqlMembers.realtime),
new GqlReturnValue(ApiGqlMembers.serviceDay),
new GqlReturnValue(ApiGqlMembers.headsign)
)
);
ApiStopResponse?response = await GetGraphQL <ApiStopResponse>(query, token);
if (response == null)
{
return(null);
}
return(response?.Stop?.StoptimesWithoutPatterns
.Select(x => new TransitStopArrivalDeparture(x))
.ToList());
}
public async Task <ApiResult <TransitStopDetails> > GetStopDetails(string stopId, DateTime forDate, CancellationToken token = default(CancellationToken))
{
GqlQuery query = new GqlQuery(ApiGqlMembers.stop)
.WithParameters(
new GqlParameter(ApiGqlMembers.id, stopId)
)
.WithReturnValues(
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.name),
new GqlInlineMethodReturnValue(ApiGqlMembers.stoptimesForServiceDate, new List <GqlParameter> {
new GqlParameter(ApiGqlMembers.date, forDate)
},
new GqlReturnValue(ApiGqlMembers.pattern,
new GqlReturnValue(ApiGqlMembers.route,
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.mode),
new GqlReturnValue(ApiGqlMembers.shortName),
new GqlReturnValue(ApiGqlMembers.longName)
)
),
new GqlReturnValue(ApiGqlMembers.stoptimes,
new GqlReturnValue(ApiGqlMembers.realtimeState),
new GqlReturnValue(ApiGqlMembers.scheduledArrival),
new GqlReturnValue(ApiGqlMembers.scheduledDeparture),
new GqlReturnValue(ApiGqlMembers.realtimeArrival),
new GqlReturnValue(ApiGqlMembers.realtimeDeparture),
new GqlReturnValue(ApiGqlMembers.realtime),
new GqlReturnValue(ApiGqlMembers.stopHeadsign)
)
)
);
ApiResult <ApiStop> response = await GetGraphQLAsync <ApiStop>(query, token);
if (!response.HasResult)
{
return(ApiResult <TransitStopDetails> .FailWithReason(response.Failure.Reason));
}
return(new ApiResult <TransitStopDetails>(new TransitStopDetails(response.Result, forDate)));
}
private async Task <ApiResult <T> > GetGraphQLAsync <T>(GqlQuery query, CancellationToken token = default(CancellationToken))
{
string parsedQuery = query.ParseToJsonString(DateParsingStrategy.NoSeparators);
HttpStringContent stringContent = CreateJsonStringContent(parsedQuery);
Uri uri = new Uri(DefaultGqlRequestUrl);
try
{
HttpResponseMessage response = await _networkClient.PostAsync(uri, stringContent, token).ConfigureAwait(false);
if (response == null || !response.IsSuccessStatusCode)
{
LogHttpFailure(response).DoNotAwait();
if (response?.StatusCode == HttpStatusCode.ServiceUnavailable)
{
return(ApiResult <T> .FailWithReason(FailureReason.ServerDown));
}
else
{
return(ApiResult <T> .Fail);
}
}
T result = await UnwrapGqlResposne <T>(response).ConfigureAwait(false);
return(new ApiResult <T>(result));
}
catch (Exception ex) when(ex is HttpRequestException || ex is COMException || ex is OperationCanceledException)
{
if (ex is OperationCanceledException)
{
return(ApiResult <T> .FailWithReason(FailureReason.Canceled));
}
else
{
LogException(ex);
return(ApiResult <T> .FailWithReason(FailureReason.NoConnection));
}
}
}
public async Task <TransitStopDetails?> GetStopDetails(string stopId, DateTime forDate, CancellationToken token)
{
GqlQuery query = new GqlQuery(ApiGqlMembers.stop)
.WithParameters(
new GqlParameter(ApiGqlMembers.id, stopId)
)
.WithReturnValues(
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.name),
new GqlInlineMethodReturnValue(ApiGqlMembers.stoptimesForServiceDate, new List <GqlParameter> {
new GqlParameter(ApiGqlMembers.date, forDate)
},
new GqlReturnValue(ApiGqlMembers.pattern,
new GqlReturnValue(ApiGqlMembers.route,
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.mode),
new GqlReturnValue(ApiGqlMembers.shortName),
new GqlReturnValue(ApiGqlMembers.longName)
)
),
new GqlReturnValue(ApiGqlMembers.stoptimes,
new GqlReturnValue(ApiGqlMembers.realtimeState),
new GqlReturnValue(ApiGqlMembers.scheduledArrival),
new GqlReturnValue(ApiGqlMembers.scheduledDeparture),
new GqlReturnValue(ApiGqlMembers.realtimeArrival),
new GqlReturnValue(ApiGqlMembers.realtimeDeparture),
new GqlReturnValue(ApiGqlMembers.realtime),
new GqlReturnValue(ApiGqlMembers.headsign)
)
)
);
ApiStopResponse?response = await GetGraphQL <ApiStopResponse>(query, token);
if (response == null)
{
return(null);
}
return(new TransitStopDetails(response.Stop, forDate));
}
/// <summary>
/// Query for entities.
/// </summary>
/// <param name="project_id">Project ID against which to make the request.</param>
/// <param name="partition_id">
/// Entities are partitioned into subsets, identified by a partition ID.
/// Queries are scoped to a single partition.
/// This partition ID is normalized with the standard default context
/// partition ID.
/// </param>
/// <param name="read_options">The options for this query.</param>
/// <param name="gql_query">The GQL query to run.</param>
/// <param name="cancellationToken">If not null, a <see cref="CancellationToken"/> to use for this RPC.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override Task <RunQueryResponse> RunQueryAsync(
string projectId,
PartitionId partitionId,
ReadOptions readOptions,
GqlQuery gqlQuery,
CancellationToken?cancellationToken = null,
CallSettings callSettings = null)
{
RunQueryRequest request = new RunQueryRequest
{
ProjectId = projectId,
PartitionId = partitionId,
ReadOptions = readOptions,
GqlQuery = gqlQuery,
};
return(GrpcClient.RunQueryAsync(
request,
_clientHelper.BuildCallOptions(cancellationToken, callSettings)
).ResponseAsync);
}
public void EagerGqlQuery()
{
string projectId = _fixture.ProjectId;
string namespaceId = _fixture.NamespaceId;
// Snippet: RunQuery(GqlQuery,*,*)
DatastoreDb db = DatastoreDb.Create(projectId, namespaceId);
GqlQuery gqlQuery = new GqlQuery
{
QueryString = "SELECT * FROM book WHERE author = @author LIMIT @limit",
NamedBindings =
{
{ "author", new GqlQueryParameter {
Value = "Jane Austen"
} },
{ "limit", new GqlQueryParameter {
Value = 10
} }
},
};
DatastoreQueryResults results = db.RunQuery(gqlQuery);
// RunQuery fetches all the results into memory in a single call.
// Constrast this with RunQueryLazily, which merely prepares an enumerable
// query. Always specify a limit when you use RunQuery, to avoid running
// out of memory.
foreach (Entity entity in results.Entities)
{
Console.WriteLine(entity);
}
// End snippet
// This will run the query again, admittedly...
Assert.Equal(1, results.Entities.Count);
Entity book = results.Entities[0];
Assert.Equal("Jane Austen", (string)book["author"]);
Assert.Equal("Pride and Prejudice", (string)book["title"]);
}
// Some debug stuff for testing out alerts. HSL doesn't publish alerts very often,
// and also doesn't have a Test Alerts endpoint, so we can just stub out the real call
// with some pregenerated data.
//private const string hardcodedAlertsTestResponse = "{\"data\":{\"alerts\":[{\"id\": \"1\", \"alertHeaderTextTranslations\":[],\"alertDescriptionTextTranslations\":[{\"text\":\"Raitiolinja 1A Käpylän suuntaan , myöhässä. Syy: tekninen vika. Arvioitu kesto: 17:28 - 17:40.\",\"language\":\"fi\"},{\"text\":\"Spårvägslinje 1A mot Kottby , försenad. Orsak: tekniska problem. Beräknad tid: 17:28 - 17:40.\",\"language\":\"sv\"},{\"text\":\"Tram 1A to Käpylä , delayed. Cause: technical problems. Estimated time: 17:28 - 17:40.\",\"language\":\"en\"}],\"alertUrl\":null,\"effectiveStartDate\":1494944983,\"effectiveEndDate\":1494945600,\"route\":{\"gtfsId\":\"HSL:1001A\"},\"stop\":null},{\"id\": \"2\", \"alertHeaderTextTranslations\":[],\"alertDescriptionTextTranslations\":[{\"text\":\"Helsingin sisäisen liikenteen linja 67 Rautatientorilta, klo 17:00 peruttu. Syy: tekninen vika.\",\"language\":\"fi\"},{\"text\":\"Helsingfors lokaltrafik, linje 67 från Järnvägstorget, kl. 17:00 inställd. Orsak: tekniska problem.\",\"language\":\"sv\"},{\"text\":\"Helsinki local traffic, line 67 from Rautatientori, 17:00 cancelled.Cause: technical problems.\",\"language\":\"en\"}],\"alertUrl\":null,\"effectiveStartDate\":1494943500,\"effectiveEndDate\":1494946800,\"route\":{\"gtfsId\":\"HSL:1067\"},\"stop\":null}]}}";
//new ApiResult<IEnumerable<ApiAlert>>(
// JsonConvert.DeserializeObject<ApiDataContainer>(hardcodedAlertsTestResponse)
// .Data
// .First
// .First
// .ToObject<IEnumerable<ApiAlert>>());
public async Task <ApiResult <IEnumerable <TransitTrafficAlert> > > GetTrafficAlertsAsync(CancellationToken token = default(CancellationToken))
{
GqlQuery query = new GqlQuery(ApiGqlMembers.alerts)
.WithReturnValues(
new GqlReturnValue(ApiGqlMembers.id),
new GqlReturnValue(ApiGqlMembers.alertHeaderTextTranslations,
new GqlReturnValue(ApiGqlMembers.text),
new GqlReturnValue(ApiGqlMembers.language)
),
new GqlReturnValue(ApiGqlMembers.alertDescriptionTextTranslations,
new GqlReturnValue(ApiGqlMembers.text),
new GqlReturnValue(ApiGqlMembers.language)
),
new GqlReturnValue(ApiGqlMembers.alertUrl),
new GqlReturnValue(ApiGqlMembers.effectiveStartDate),
new GqlReturnValue(ApiGqlMembers.effectiveEndDate),
new GqlReturnValue(ApiGqlMembers.route,
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.shortName),
new GqlReturnValue(ApiGqlMembers.longName),
new GqlReturnValue(ApiGqlMembers.mode)
),
new GqlReturnValue(ApiGqlMembers.stop,
new GqlReturnValue(ApiGqlMembers.gtfsId)
)
);
ApiResult <IEnumerable <ApiAlert> > response = await GetGraphQLAsync <IEnumerable <ApiAlert> >(query, token);
if (!response.HasResult)
{
return(ApiResult <IEnumerable <TransitTrafficAlert> > .FailWithReason(response.Failure.Reason));
}
return(new ApiResult <IEnumerable <TransitTrafficAlert> >(response.Result.Select(x => new TransitTrafficAlert(x, _settingsService.CurrentLanguage))));
}
//---GRAPHQL REQUESTS---
public async Task <ApiResult <IEnumerable <TransitStop> > > GetStopsAsync(string searchString, CancellationToken token = default(CancellationToken))
{
Uri uri = new Uri(DefaultGqlRequestUrl);
GqlQuery query = new GqlQuery(ApiGqlMembers.stops)
.WithParameters(new GqlParameter(ApiGqlMembers.name, searchString))
.WithReturnValues(
new GqlReturnValue(ApiGqlMembers.id),
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.lat),
new GqlReturnValue(ApiGqlMembers.lon),
new GqlReturnValue(ApiGqlMembers.name),
new GqlReturnValue(ApiGqlMembers.code),
new GqlReturnValue(ApiGqlMembers.routes,
new GqlReturnValue(ApiGqlMembers.mode)
)
);
var response = await GetGraphQLAsync <List <ApiStop> >(query);
if (!response.HasResult)
{
return(ApiResult <IEnumerable <TransitStop> > .FailWithReason(response.Failure.Reason));
}
if (response.HasResult && !response.Result.Any())
{
LogLogicFailure(FailureReason.NoResults);
return(ApiResult <IEnumerable <TransitStop> > .FailWithReason(FailureReason.NoResults));
}
return(new ApiResult <IEnumerable <TransitStop> >(response.Result.Select(x => new TransitStop
{
Name = x.Name,
Code = x.Code,
Coords = BasicGeopositionExtensions.Create(0.0, x.Lon, x.Lat),
GtfsId = x.GtfsId,
Id = Guid.NewGuid()
})));
}
public async Task <ApiResult <IEnumerable <TransitLine> > > GetLinesAsync(IEnumerable <string> gtfsIds, CancellationToken token = default(CancellationToken))
{
GqlQuery query = new GqlQuery(ApiGqlMembers.routes)
.WithParameters(new GqlParameter(ApiGqlMembers.ids, gtfsIds))
.WithReturnValues(
new GqlReturnValue(ApiGqlMembers.shortName),
new GqlReturnValue(ApiGqlMembers.longName),
new GqlReturnValue(ApiGqlMembers.mode),
new GqlReturnValue(ApiGqlMembers.patterns,
new GqlReturnValue(ApiGqlMembers.stops,
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.name),
new GqlReturnValue(ApiGqlMembers.lat),
new GqlReturnValue(ApiGqlMembers.lon)
),
new GqlReturnValue(ApiGqlMembers.geometry,
new GqlReturnValue(ApiGqlMembers.lat),
new GqlReturnValue(ApiGqlMembers.lon)
)
)
);
ApiResult <IEnumerable <ApiRoute> > response = await GetGraphQLAsync <IEnumerable <ApiRoute> >(query, token);
if (!response.HasResult)
{
return(ApiResult <IEnumerable <TransitLine> > .FailWithReason(response.Failure.Reason));
}
if (response.HasResult && !response.Result.Any())
{
LogLogicFailure(FailureReason.NoResults);
return(ApiResult <IEnumerable <TransitLine> > .FailWithReason(FailureReason.NoResults));
}
return(new ApiResult <IEnumerable <TransitLine> >(response.Result.Select(x => new TransitLine(x))));
}
public void GqlQueryIsTransformed()
{
var structured = new Query
{
Limit = 10,
Projection = { "foo", "bar" }
};
// No, this isn't real GQL. But it's an easy way of testing things.
var gql = new GqlQuery {
QueryString = structured.ToString()
};
var server = new FakeServer(4);
var streamer = new QueryStreamer(new RunQueryRequest {
GqlQuery = gql
}, server.CreateApiCall(), null);
AssertEntities(streamer, 0, 10);
var firstStructured = new Query(structured)
{
Limit = 6, StartCursor = ByteString.CopyFromUtf8("4")
};
Assert.Equal(firstStructured, server.Requests[1].Query);
}
/// <summary>
/// Executes the given GQL query, returning a result set that can be viewed as an asynchronous
/// sequence of entities, entity results (with cursors), batches, or raw API responses.
/// </summary>
/// <remarks>
/// The results are requested lazily: no API calls will be made until the application starts
/// iterating over the results. Iterating over the same <see cref="DatastoreQueryResults"/> object
/// multiple times will execute the query again, potentially returning different results.
/// </remarks>
/// <param name="query">The query to execute. Must not be null.</param>
/// <param name="readConsistency">If not null, overrides the read consistency of the query.</param>
/// <param name="callSettings">If not null, applies overrides to RPC calls.</param>
/// <returns>A <see cref="DatastoreQueryResults"/> representing the result of the query.</returns>
public virtual DatastoreAsyncQueryResults RunQueryAsync(
GqlQuery gqlQuery, ReadConsistency?readConsistency = null, CallSettings callSettings = null)
{
throw new NotImplementedException();
}
/// <summary> /// Creates a request for GraphQL. /// </summary> /// <returns></returns> public static FluentHttpRequestBuilder CreateGqlRequest(this IFluentHttpClient fluentHttpClient, GqlQuery query) => fluentHttpClient.CreateRequest().AsGql(query);
/// <summary> /// Set request as GraphQL. /// </summary> ///<returns>Returns request builder for chaining.</returns> public static FluentHttpRequestBuilder AsGql(this FluentHttpRequestBuilder builder, GqlQuery query) => builder.AsPost().WithBody(query);
/// <summary>
/// Lazily executes the given structured query in this transaction for asynchronous consumption.
/// </summary>
/// <remarks>
/// <para>
/// Using a transaction ensures that a commit operation will fail if any of the entities returned
/// by this query have been modified while the transaction is active. Note that modifications performed
/// as part of this operation are not reflected in the query results.
/// </para>
/// <para>
/// The results are requested lazily: no API calls will be made until the application starts
/// iterating over the results. Iterating over the same <see cref="LazyDatastoreQuery"/> object
/// multiple times will execute the query again, potentially returning different results.
/// </para>
/// </remarks>
/// <param name="gqlQuery">The query to execute. Must not be null.</param>
/// <param name="callSettings">If not null, applies overrides to RPC calls.</param>
/// <returns>An <see cref="AsyncLazyDatastoreQuery"/> representing the result of the query.</returns>
public virtual AsyncLazyDatastoreQuery RunQueryLazilyAsync(GqlQuery gqlQuery, CallSettings callSettings = null)
{
throw new NotImplementedException();
}
/// <summary> /// Runs the given query eagerly and asynchronously in this transaction, retrieving all results in memory and indicating whether more /// results may be available beyond the query's limit. Use this method when your query has a limited /// number of results, for example to build a web application which fetches results in pages. /// </summary> /// <remarks> /// <para> /// Using a transaction ensures that a commit operation will fail if any of the entities returned /// by this query have been modified while the transaction is active. Note that modifications performed /// as part of this operation are not reflected in the query results. /// </para> /// <para>The default implementation of this method delegates to <see cref="RunQueryLazilyAsync(GqlQuery, CallSettings)"/> /// and calls <see cref="AsyncLazyDatastoreQuery.GetAllResultsAsync"/> on the return value.</para> /// </remarks> /// <param name="query">The query to execute. Must not be null.</param> /// <param name="callSettings">If not null, applies overrides to RPC calls.</param> /// <returns>A task representing the asynchronous operation. The result of the task is the complete set of query results.</returns> public virtual Task <DatastoreQueryResults> RunQueryAsync(GqlQuery query, CallSettings callSettings = null) => RunQueryLazilyAsync(query, callSettings).GetAllResultsAsync();
/// <summary> /// Runs the given query eagerly in this transaction, retrieving all results in memory and indicating whether more /// results may be available beyond the query's limit. Use this method when your query has a limited /// number of results, for example to build a web application which fetches results in pages. /// </summary> /// <remarks> /// <para> /// Using a transaction ensures that a commit operation will fail if any of the entities returned /// by this query have been modified while the transaction is active. Note that modifications performed /// as part of this operation are not reflected in the query results. /// </para> /// <para>The default implementation of this method delegates to <see cref="RunQueryLazily(GqlQuery, CallSettings)"/> /// and calls <see cref="LazyDatastoreQuery.GetAllResults"/> on the return value.</para> /// </remarks> /// <param name="query">The query to execute. Must not be null.</param> /// <param name="callSettings">If not null, applies overrides to RPC calls.</param> /// <returns>The complete query results.</returns> public virtual DatastoreQueryResults RunQuery(GqlQuery query, CallSettings callSettings = null) => RunQueryLazily(query, callSettings).GetAllResults();
/// <summary>
/// Get a list of POCOs from a query using GQL
/// </summary>
/// <param name="query">The query to run (you can ignore the kind)</param>
/// <typeparam name="TPoco">The POCO you want back</typeparam>
public virtual async Task <IList <TPoco> > Query <TPoco>(GqlQuery query) where TPoco : new()
{
var res = await datastoreDb.RunQueryAsync(query);
return(res.Entities.Select(x => orm.EntityToPoco <TPoco>(x)).ToList());
}
public async Task <IEnumerable <TEntity> > FindInAsync(IDictionary <string, dynamic> fieldComparisons)
{
var gqlFilters = new List <string>();
foreach (var comparison in fieldComparisons)
{
var field = comparison.Key;
var values = comparison.Value;
var localGqlFilters = new List <string>();
if (gqlFilters.Count == 0)
{
if (values is Array)
{
foreach (var val in values)
{
localGqlFilters.Add(val is string?$"{field}='{val}'" : $"{field}={val}");
}
}
else
{
localGqlFilters.Add(values is string?$"{field}='{values}'" : $"{field}={values}");
}
}
else
{
foreach (var gql in gqlFilters)
{
if (values is Array)
{
foreach (var val in values)
{
localGqlFilters.Add(val is string?$"{gql} AND {field}='{val}'" : $"{gql} AND {field}={val}");
}
}
else
{
localGqlFilters.Add(values is string?$"{gql} AND {field}='{values}'" : $"{gql} AND {field}={values}");
}
}
}
gqlFilters = localGqlFilters;
}
var entities = new List <TEntity>();
foreach (var filter in gqlFilters)
{
var q = new GqlQuery
{
QueryString = $"SELECT * FROM {_kind} WHERE {filter}",
AllowLiterals = true
};
var results = await _database.RunQueryAsync(q);
entities.AddRange(results.Entities.Select(BuildDalEntity));
}
return(entities);
}
public RunQueryResponse Gql(GqlQuery gqlQuery)
{
return(_context.Invoke(f => f.Gql(gqlQuery)));
}
public override object Execute(Expression expression)
{
var state = Translate(expression);
// Perform local indexing if needed
if (Configuration.GenerateIndexYAMLFile)
{
BuildIndex(state);
}
// Build a query
var datastore = new Google.Apis.Datastore.v1beta3.DatastoreService(Authenticator.GetInitializer());
var dict = state.Parameters.ToDictionary(x => x.ParameterName, parameter => new GqlQueryParameter()
{
Value = ReadQuery_ConvertTypeToValueType(parameter.ParameterName, parameter.Value, parameter.TypeCode)
});
var gql = new GqlQuery
{
QueryString = state.QueryBuilder.ToString(),
AllowLiterals = false, // enforce parameterized queries
NamedBindings = dict
//NameArgs = state.Parameters.Select(x => new GqlQueryArg { Name = x.ParameterName,
// Value = ReadQuery_ConvertTypeToValueType(x.ParameterName, x.Value, x.TypeCode) }).ToList()
};
// Grab results
var result = datastore.Projects.RunQuery(new RunQueryRequest
{
GqlQuery = gql
}, Authenticator.GetProjectId()).Execute();
// Project if necessary / Select() method
if (state.Projector != null)
{
var elementType = TypeSystem.GetElementType(expression.Type);
var projector = state.Projector.Compile();
return(Activator.CreateInstance(
typeof(ProjectionReader <>).MakeGenericType(elementType),
BindingFlags.Instance | BindingFlags.NonPublic, null,
new object[] { result.Batch.EntityResults.Select(x => x.Entity), projector },
null
));
}
// First()/Single() method
if (state.QueryState.HasFlag(QueryState.IsFirst) || state.QueryState.HasFlag(QueryState.IsSingle))
{
if (result.Batch.EntityResults.Count == 0 && !state.QueryState.HasFlag(QueryState.AllowFirstSingleOrDefault))
{
throw new InvalidOperationException("Sequence contains no elements");
}
if (result.Batch.EntityResults.Count > 1 && state.QueryState.HasFlag(QueryState.IsSingle))
{
throw new InvalidOperationException("Sequence contains more than one element");
}
if (result.Batch.EntityResults.Any())
{
return(_serializer.DeserializeEntity(result.Batch.EntityResults[0].Entity));
}
return(null);
}
// Any() method
if (state.QueryState.HasFlag(QueryState.IsAny))
{
return(result.Batch.EntityResults.Any());
}
// Regular Where() query
return(result.Batch.EntityResults.Select(entityResult => _serializer.DeserializeEntity(entityResult.Entity)).ToList());
}
/// <summary>
/// Returns a travel plan.
/// </summary>
/// <param name="details"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task <ApiResult <TripPlan> > PlanTripAsync(TripQueryDetails details, CancellationToken token = default(CancellationToken))
{
Uri uri = new Uri(DefaultGqlRequestUrl);
GqlQuery query = new GqlQuery(ApiGqlMembers.plan)
.WithParameters(
new GqlParameter(ApiGqlMembers.from, new GqlTuple {
{ ApiGqlMembers.lat, details.FromPlaceCoords.Lat }, { ApiGqlMembers.lon, details.FromPlaceCoords.Lon }
}),
new GqlParameter(ApiGqlMembers.intermediatePlaces, new GqlParameterArray(details.IntermediateCoords.Select(x => new GqlTuple {
{ ApiGqlMembers.lat, x.Lat }, { ApiGqlMembers.lon, x.Lon }
}))),
new GqlParameter(ApiGqlMembers.to, new GqlTuple {
{ ApiGqlMembers.lat, details.ToPlaceCoordinates.Lat }, { ApiGqlMembers.lon, details.ToPlaceCoordinates.Lon }
}),
new GqlParameter(ApiGqlMembers.numItineraries, 5),
new GqlParameter(ApiGqlMembers.time, details.Time),
new GqlParameter(ApiGqlMembers.date, details.Date),
new GqlParameter(ApiGqlMembers.arriveBy, details.IsTimeTypeArrival),
new GqlParameter(ApiGqlMembers.modes, details.TransitModes),
new GqlParameter(ApiGqlMembers.walkSpeed, details.WalkSpeed.UnderlyingMetersPerSecond),
new GqlParameter(ApiGqlMembers.walkReluctance, details.WalkAmount.UnderlyingWalkReluctance)
)
.WithReturnValues(
new GqlReturnValue(ApiGqlMembers.from,
new GqlReturnValue(ApiGqlMembers.name)
),
new GqlReturnValue(ApiGqlMembers.to,
new GqlReturnValue(ApiGqlMembers.name)
),
new GqlReturnValue(ApiGqlMembers.itineraries,
new GqlReturnValue(ApiGqlMembers.legs,
new GqlReturnValue(ApiGqlMembers.startTime),
new GqlReturnValue(ApiGqlMembers.endTime),
new GqlReturnValue(ApiGqlMembers.mode),
new GqlReturnValue(ApiGqlMembers.duration),
new GqlReturnValue(ApiGqlMembers.realTime),
new GqlReturnValue(ApiGqlMembers.distance),
new GqlReturnValue(ApiGqlMembers.transitLeg),
new GqlReturnValue(ApiGqlMembers.legGeometry,
new GqlReturnValue(ApiGqlMembers.length),
new GqlReturnValue(ApiGqlMembers.points)
),
new GqlReturnValue(ApiGqlMembers.intermediateStops,
new GqlReturnValue(ApiGqlMembers.name),
new GqlReturnValue(ApiGqlMembers.lat),
new GqlReturnValue(ApiGqlMembers.lon)
),
new GqlReturnValue(ApiGqlMembers.from,
new GqlReturnValue(ApiGqlMembers.name),
new GqlReturnValue(ApiGqlMembers.lat),
new GqlReturnValue(ApiGqlMembers.lon)
),
new GqlReturnValue(ApiGqlMembers.to,
new GqlReturnValue(ApiGqlMembers.name),
new GqlReturnValue(ApiGqlMembers.lat),
new GqlReturnValue(ApiGqlMembers.lon)
),
new GqlReturnValue(ApiGqlMembers.route,
new GqlReturnValue(ApiGqlMembers.gtfsId),
new GqlReturnValue(ApiGqlMembers.shortName)
)
),
new GqlReturnValue(ApiGqlMembers.fares,
new GqlReturnValue(ApiGqlMembers.type),
new GqlReturnValue(ApiGqlMembers.currency),
new GqlReturnValue(ApiGqlMembers.cents)
)
)
);
var response = await GetGraphQLAsync <ApiPlan>(query, token);
if (!response.HasResult)
{
return(ApiResult <TripPlan> .FailWithReason(response.Failure.Reason));
}
if (response.HasResult && response.Result?.Itineraries.Any() != true)
{
LogLogicFailure(FailureReason.NoResults);
return(ApiResult <TripPlan> .FailWithReason(FailureReason.NoResults));
}
return(new ApiResult <TripPlan>(new TripPlan(response.Result, details.FromPlaceString, details.ToPlaceString)));
}
