public void EagerGqlQuery()
{
string projectId = _fixture.ProjectId;
string namespaceId = _fixture.NamespaceId;
// Snippet: RunQuery(GqlQuery,*)
DatastoreDb db = DatastoreDb.Create(projectId, namespaceId);
KeyFactory keyFactory = db.CreateKeyFactory("player");
// Prepare the data: a player with two game child entities
Entity player = new Entity
{
Key = keyFactory.CreateIncompleteKey(),
["name"] = "Sophie"
};
Key playerKey = db.Insert(player);
Entity game1 = new Entity
{
Key = playerKey.WithElement(new PathElement {
Kind = "game"
}),
["score"] = 10,
["timestamp"] = new DateTime(2017, 2, 16, 8, 35, 0, DateTimeKind.Utc)
};
Entity game2 = new Entity
{
Key = playerKey.WithElement(new PathElement {
Kind = "game"
}),
["score"] = 25,
["timestamp"] = new DateTime(2017, 3, 15, 10, 35, 0, DateTimeKind.Utc)
};
db.Insert(game1, game2);
// Perform a query within a transaction
using (DatastoreTransaction transaction = db.BeginTransaction())
{
// Any query executed in a transaction must at least have an ancestor filter.
GqlQuery query = new GqlQuery
{
QueryString = "SELECT * FROM game WHERE __key__ HAS ANCESTOR @player LIMIT @limit",
NamedBindings =
{
{ "player", playerKey },
{ "limit", 10 }
}
};
DatastoreQueryResults results = db.RunQuery(query);
// 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
}
public void StructuredQuery()
{
string projectId = _fixture.ProjectId;
string namespaceId = _fixture.NamespaceId;
// Snippet: RunQuery(Query,*,*)
DatastoreDb db = DatastoreDb.Create(projectId, namespaceId);
Query query = new Query("book")
{
Filter = Filter.Equal("author", "Jane Austen")
};
DatastoreQueryResults results = db.RunQuery(query);
// DatastoreQueryResults implements IEnumerable<Entity>, but you can
// call AsEntityResults(), AsBatches() or AsResponses() to see the query
// results in whatever way makes most sense for your application.
foreach (Entity entity in results)
{
Console.WriteLine(entity);
}
// End snippet
// This will run the query again, admittedly...
List <Entity> entities = results.ToList();
Assert.Equal(1, entities.Count);
Entity book = entities[0];
Assert.Equal("Jane Austen", (string)book["author"]);
Assert.Equal("Pride and Prejudice", (string)book["title"]);
}
public async Task EagerStructuredQueryAsync()
{
string projectId = _fixture.ProjectId;
string namespaceId = _fixture.NamespaceId;
// Snippet: RunQueryAsync(Query,*,*)
DatastoreDb db = DatastoreDb.Create(projectId, namespaceId);
Query query = new Query("book")
{
Filter = Filter.Equal("author", "Jane Austen")
};
DatastoreQueryResults results = await db.RunQueryAsync(query);
// 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"]);
}
public void GqlQuery()
{
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",
NamedBindings = { { "author", new GqlQueryParameter {
Value = "Jane Austen"
} } },
};
DatastoreQueryResults results = db.RunQuery(gqlQuery);
// DatastoreQueryResults implements IEnumerable<Entity>, but you can
// call AsEntityResults(), AsBatches() or AsResponses() to see the query
// results in whatever way makes most sense for your application.
foreach (Entity entity in results)
{
Console.WriteLine(entity);
}
// End snippet
// This will run the query again, admittedly...
List <Entity> entities = results.ToList();
Assert.Equal(1, entities.Count);
Entity book = entities[0];
Assert.Equal("Jane Austen", (string)book["author"]);
Assert.Equal("Pride and Prejudice", (string)book["title"]);
}
public async Task EagerGqlQueryAsync()
{
string projectId = _fixture.ProjectId;
string namespaceId = _fixture.NamespaceId;
// Snippet: RunQueryAsync(GqlQuery,*,*)
DatastoreDb db = DatastoreDb.Create(projectId, namespaceId);
GqlQuery gqlQuery = new GqlQuery
{
QueryString = "SELECT * FROM book WHERE author = @author",
NamedBindings = { { "author", new GqlQueryParameter {
Value = "Jane Austen"
} } },
};
DatastoreQueryResults results = await db.RunQueryAsync(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"]);
}
public void AsBatches()
{
var results = new DatastoreQueryResults(_responses.Select(r => r.Clone()));
var expected = new[] { _responses[0].Batch, _responses[1].Batch, _responses[2].Batch, _responses[3].Batch };
Assert.Equal(expected, results.AsBatches());
}
public void PaginateWithCursor()
{
string projectId = _fixture.ProjectId;
string namespaceId = _fixture.NamespaceId;
ByteString pageCursor = null;
int pageSize = 5;
// Sample: PaginateWithCursor
Query query = new Query("Task")
{
Limit = pageSize, StartCursor = pageCursor ?? ByteString.Empty
};
DatastoreDb db = DatastoreDb.Create(projectId, namespaceId);
DatastoreQueryResults results = db.RunQueryLazily(query, ReadConsistency.Eventual).GetAllResults();
foreach (Entity entity in results.Entities)
{
// Do something with the task entity
}
if (results.MoreResults == MoreResultsType.MoreResultsAfterLimit)
{
ByteString nextPageCursor = results.EndCursor;
// Store nextPageCursor to get the next page later.
}
// End sample
}
private static bool IsEmpty(DatastoreQueryResults results)
{
foreach (var result in results)
{
return(false);
}
return(true);
}
public void TestRunQuery()
{
UpsertTaskList();
// [START run_query]
Query query = new Query("Task");
DatastoreQueryResults tasks = _db.RunQuery(query);
// [END run_query]
Assert.False(IsEmpty(tasks));
}
public void AsEntityResults()
{
var results = new DatastoreQueryResults(_responses.Select(r => r.Clone()));
var expected = _entityResults.ToList();
expected[4].Cursor = _responses[1].Batch.EndCursor;
expected[14].Cursor = _responses[2].Batch.EndCursor;
expected[19].Cursor = _responses[3].Batch.EndCursor;
Assert.Equal(expected, results.AsEntityResults());
}
public Entity GetOneResult(Query q)
{
DatastoreQueryResults results = db.RunQuery(q);
if (results.Entities.Count == 0)
{
return(null);
}
else
{
return(results.Entities[0]);
}
}
// Key - idContent
// Value - Totals
public async Task <IDictionary <string, Content> > GetPhotoTotalsByTopic(string topic)
{
// select All UserPhoto, where
var keyTopic = new Key().WithElement("TopicTotals", topic);
Query query = new Query("ContentTotals")
{
Filter = Filter.HasAncestor(keyTopic),
};
DatastoreQueryResults results = await Db.RunQueryAsync(query, ReadOptions.Types.ReadConsistency.Strong);
var userPhotos = results.Entities.Select(x => x.ToContent());
return(userPhotos.ToDictionary(x => x.IdContent, x => x));
}
// Key - idContent
// Value - My flags
public async Task <IDictionary <string, UserPhoto> > GetUserPhotosByTopic(string topic, string idUser)
{
// select All UserPhoto, where
var keyTopic = new Key().WithElement("Topic", topic);
var keyTopicAndUser = new KeyFactory(keyTopic, "User").CreateKey(idUser);
Query query = new Query("UserPhoto")
{
Filter = Filter.HasAncestor(keyTopicAndUser),
};
DatastoreQueryResults results = await Db.RunQueryAsync(query, ReadOptions.Types.ReadConsistency.Strong);
var userPhotos = results.Entities.Select(x => x.ToUserPhoto());
return(userPhotos.ToDictionary(x => x.IdContent, x => x));
}
public Model_Account FindAccount(string username, string discriminator)
{
Query query = new Query(Controller_Account.Enum.account)
{
Filter = Filter.And(Filter.Equal(Controller_Account.Enum.username, username),
Filter.Equal(Controller_Account.Enum.discriminator, discriminator))
};
DatastoreQueryResults results = db.RunQuery(query);
if (results.Entities.Count == 0)
{
return(null);
}
else
{
return(Controller_Account.BuildController(results.Entities[0]).model);
}
}
public Dictionary <string, double> GetMarketOdds(Guid gameId)
{
string gameIdString = gameId.ToString();
Key key = _marketOddsKeyFactory.CreateKey(gameIdString);
string store = ConfigurationManager.AppSettings["datastoreMarketOddsKey"];
Query query = new Query(store)
{
Filter = Filter.Equal("__key__", key)
};
DatastoreQueryResults datastoreQueryResults = DatastoreDb.RunQuery(query);
if (datastoreQueryResults.Entities.Count == 0)
{
return(new Dictionary <string, double>());
}
string odds = datastoreQueryResults.Entities[0].Properties["odds"].StringValue;
Dictionary <string, double> oddsDictionary = JsonConvert.DeserializeObject <Dictionary <string, double> >(odds);
return(oddsDictionary);
}
private static bool IsEmpty(DatastoreQueryResults results) => results.Entities.Count == 0;
public void AsEntities()
{
var results = new DatastoreQueryResults(_responses.Select(r => r.Clone()));
Assert.Equal(_entities, results);
}
