public OpenAsyncSession ( ) : IAsyncDocumentSession | ||
리턴 | IAsyncDocumentSession |
public void AsyncLoad() { using (GetNewServer()) using (var store = new DocumentStore { Url = "http://localhost:8079" }.Initialize()) { using (var session = store.OpenAsyncSession()) { session.Store(new Dummy() ); session.SaveChangesAsync().Wait(); } using (var session = store.OpenAsyncSession()) { session.LoadAsync<Dummy>("dummies/1").Wait(); Assert.Equal(0, store.JsonRequestFactory.NumberOfCachedRequests); } using (var session = store.OpenAsyncSession()) { session.LoadAsync<Dummy>("dummies/1").Wait(); Assert.Equal(1, store.JsonRequestFactory.NumberOfCachedRequests); } } }
public IEnumerable<Task> CanPerformASimpleWhere() { var dbname = GenerateNewDatabaseName(); using (var documentStore = new DocumentStore {Url = Url + Port}.Initialize()) { yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname); var entity = new Company {Name = "Async Company #1", Id = "companies/1"}; using (var session = documentStore.OpenAsyncSession(dbname)) { session.Store(entity); yield return session.SaveChangesAsync(); } using (var session = documentStore.OpenAsyncSession(dbname)) { var query = session.Query<Company>() .Where(x => x.Name == "Async Company #1") .ToListAsync(); yield return query; Assert.AreEqual(1, query.Result.Count); Assert.AreEqual("Async Company #1", query.Result[0].Name); } } }
public IEnumerable<Task> IncludingARelatedEntityShouldAvoidHittingTheServerTwice() { var dbname = GenerateNewDatabaseName(); using (var documentStore = new DocumentStore {Url = Url + Port}.Initialize()) { yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname); var customer = new Customer {Name = "Customer #1", Id = "customer/1", Email = "*****@*****.**"}; var order = new Order {Id = "orders/1", Note = "Hello", Customer = new DenormalizedReference {Id = customer.Id, Name = customer.Name}}; using (var session = documentStore.OpenAsyncSession(dbname)) { session.Store(customer); session.Store(order); yield return session.SaveChangesAsync(); } using (var session = documentStore.OpenAsyncSession(dbname)) { var query = session.Advanced.AsyncLuceneQuery<Order>() .Include(x => x.Customer.Id) .WhereEquals("Id", "orders/1") .ToListAsync(); yield return query; Assert.AreEqual("Hello", query.Result.Item2[0].Note); // NOTE: this call should not hit the server var load = session.LoadAsync<Customer>(customer.Id); yield return load; Assert.AreEqual(1, session.Advanced.NumberOfRequests); } } }
public IEnumerable<Task> CanGetTotalCount() { var dbname = GenerateNewDatabaseName(); using (var documentStore = new DocumentStore {Url = Url + Port}.Initialize()) { yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname); var entity = new Company {Name = "Async Company #1", Id = "companies/1"}; using (var session = documentStore.OpenAsyncSession(dbname)) { session.Store(entity); yield return session.SaveChangesAsync(); } using (var session = documentStore.OpenAsyncSession(dbname)) { RavenQueryStatistics stats; var query = session.Query<Company>() .Customize(x => x.WaitForNonStaleResults()) .Statistics(out stats) .Where(x => x.Name == "Async Company #1") .CountAsync(); yield return query; Assert.AreEqual(1, query.Result); } } }
public void Can_query_using_async_session() { using(GetNewServer()) using(var store = new DocumentStore { Url = "http://localhost:8080" }.Initialize()) { using (var s = store.OpenAsyncSession()) { s.Store(new {Name = "Ayende"}); s.SaveChangesAsync().Wait(); } using(var s = store.OpenAsyncSession()) { var queryResultAsync = s.Advanced.AsyncLuceneQuery<dynamic>() .WhereEquals("Name", "Ayende") .ToListAsync(); queryResultAsync.Wait(); Assert.Equal("Ayende", queryResultAsync.Result[0].Name); } } }
public IEnumerable<Task> CanInsertAsyncAndMultiGetAsync() { var dbname = GenerateNewDatabaseName(); using (var documentStore = new DocumentStore {Url = Url + Port}.Initialize()) { yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname); var entity1 = new Company {Name = "Async Company #1"}; var entity2 = new Company {Name = "Async Company #2"}; using (var session_for_storing = documentStore.OpenAsyncSession(dbname)) { session_for_storing.Store(entity1); session_for_storing.Store(entity2); yield return session_for_storing.SaveChangesAsync(); } using (var session_for_loading = documentStore.OpenAsyncSession(dbname)) { var task = session_for_loading.LoadAsync<Company>(new[] {entity1.Id, entity2.Id}); yield return task; Assert.AreEqual(entity1.Name, task.Result[0].Name); Assert.AreEqual(entity2.Name, task.Result[1].Name); } } }
public IEnumerable<Task> CanQueryUsingAsyncSession() { var dbname = GenerateNewDatabaseName(); using (var documentStore = new DocumentStore {Url = Url + Port}.Initialize()) { yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname); using (var s = documentStore.OpenAsyncSession(dbname)) { s.Store(new User {Name = "Ayende"}); yield return s.SaveChangesAsync(); } using (var s = documentStore.OpenAsyncSession(dbname)) { var queryResultAsync = s.Advanced.AsyncLuceneQuery<User>() .WhereEquals("Name", "Ayende") .ToListAsync(); yield return queryResultAsync; Assert.AreEqual("Ayende", queryResultAsync.Result.Item2[0].Name); } } }
private async Task InitializeDocumentsCursor(CancellationToken cancellation) { using (var store = new DocumentStore()) { store.ParseConnectionString(configuration.ConnectionString); store.Initialize(false); using (var session = store.OpenAsyncSession()) { if (String.IsNullOrEmpty(configuration.Query)) { documentsCursor = await session.Advanced.StreamAsync<RavenJObject>(Etag.Empty, 0, int.MaxValue, null, cancellation); } else { var query = String.IsNullOrEmpty(configuration.Index) ? session.Advanced.AsyncDocumentQuery<RavenJObject>() : session.Advanced.AsyncDocumentQuery<RavenJObject>(configuration.Index); // Streaming query API does not create a dynamic index, so user have to specify one if query is provided: http://issues.hibernatingrhinos.com/issue/RavenDB-1410 documentsCursor = await session.Advanced.StreamAsync<RavenJObject>( query.Where(configuration.Query).NoCaching().NoTracking(), cancellation); } } } }
public async Task Sample() { using (var store = new DocumentStore()) { var user = new RavenJObject { {"Name", "John"} }; using (var session = store.OpenAsyncSession()) { #region write_assurance_1 await session.StoreAsync(user); await session.SaveChangesAsync(); Etag userEtag = session .Advanced .GetEtagFor(user); int replicas = await store .Replication .WaitAsync(etag: userEtag, timeout: TimeSpan.FromMinutes(1), replicas: 1); #endregion #region write_assurance_2 await store .Replication .WaitAsync(); #endregion } } }
public OpeningSession() { string databaseName = "DB1"; using (var store = new DocumentStore()) { #region open_session_2 store.OpenSession(new OpenSessionOptions()); #endregion #region open_session_3 store.OpenSession(new OpenSessionOptions { Database = databaseName }); #endregion #region open_session_4 using (IDocumentSession session = store.OpenSession()) { // code here } #endregion #region open_session_5 using (IAsyncDocumentSession session = store.OpenAsyncSession()) { // async code here } #endregion } }
public void Can_insert_sync_and_get_async() { using (var server = GetNewServer(port, path)) { var documentStore = new DocumentStore { Url = "http://localhost:" + port }; documentStore.Initialize(); var entity = new Company { Name = "Async Company" }; using (var session = documentStore.OpenSession()) { session.Store(entity); session.SaveChanges(); } using (var session = documentStore.OpenAsyncSession()) { var asyncResult = session.BeginLoad(entity.Id, null, null); if (asyncResult.CompletedSynchronously == false) asyncResult.AsyncWaitHandle.WaitOne(); var company = session.EndLoad<Company>(asyncResult); Assert.Equal("Async Company", company.Name); } } }
public void WillResultInTheSameResults_Lucene_Async() { using (GetNewServer()) using (var store = new DocumentStore { Url = "http://localhost:8079" }.Initialize()) { using (var s = store.OpenSession()) { s.Store(new User()); s.Store(new User()); s.SaveChanges(); } using (var s = store.OpenAsyncSession()) { var query = s.Advanced.AsyncLuceneQuery<User>(); for (int i = 0; i < 5; i++) { var listAsync = query.ToListAsync(); listAsync.Wait(); foreach (var user in listAsync.Result.Item2) { Assert.NotNull(user.Id); } } } } }
public async Task CanSaveAndLoad() { using (var store = new DocumentStore {Url = Url}.Initialize()) { using (var session = store.OpenAsyncSession()) { await session.StoreAsync(new User { Name = "Fitzchak" }); await session.SaveChangesAsync(); } using (var session = store.OpenAsyncSession()) { var user = await session.LoadAsync<User>("users/1"); Assert.NotNull(user); Assert.Equal("Fitzchak", user.Name); } } }
public async Task CanStartWithoutServerAsync() { using (var store = new DocumentStore { Url = "http://localhost:8079" }.Initialize()) { using (var session = store.OpenAsyncSession()) { await AssertAsync.Throws<HttpRequestException>(async () => await session.LoadAsync<User>("user/1")); } using (GetNewServer()) { using (var session = store.OpenAsyncSession()) { Assert.Null(await session.LoadAsync<Item>("items/1")); } } } }
public async Task CanStartWithoutServerAsync() { using (var store = new DocumentStore { Url = "http://localhost:8079" }.Initialize()) { using (var session = store.OpenAsyncSession()) { var aggregateException = await AssertAsync.Throws<AggregateException>(async () => await session.LoadAsync<User>("user/1")); Assert.IsType<WebException>(aggregateException.Flatten().InnerException); } using (GetNewServer()) { using (var session = store.OpenAsyncSession()) { Assert.Null(await session.LoadAsync<Item>("items/1")); } } } }
public async Task When_replicating_can_do_read_striping() { var store1 = CreateStore(); var store2 = CreateStore(); var store3 = CreateStore(); using (var session = store1.OpenAsyncSession()) { await session.StoreAsync(new Company()); await session.SaveChangesAsync(); } SetupReplication(store1.DatabaseCommands, store2, store3); WaitForDocument(store2.DatabaseCommands, "companies/1"); WaitForDocument(store3.DatabaseCommands, "companies/1"); await PauseReplicationAsync(0, store1.DefaultDatabase); await PauseReplicationAsync(1, store2.DefaultDatabase); await PauseReplicationAsync(2, store3.DefaultDatabase); using(var store = new DocumentStore { Url = store1.Url, Conventions = { FailoverBehavior = FailoverBehavior.ReadFromAllServers }, DefaultDatabase = store1.DefaultDatabase }) { store.Initialize(); var replicationInformerForDatabase = store.GetReplicationInformerForDatabase(); await replicationInformerForDatabase.UpdateReplicationInformationIfNeeded((AsyncServerClient)store.AsyncDatabaseCommands); Assert.Equal(2, replicationInformerForDatabase.ReplicationDestinationsUrls.Count); foreach (var ravenDbServer in servers) { ravenDbServer.Server.ResetNumberOfRequests(); Assert.Equal(0, ravenDbServer.Server.NumberOfRequests); } for (int i = 0; i < 6; i++) { using(var session = store.OpenAsyncSession()) { Assert.NotNull(await session.LoadAsync<Company>("companies/1")); } } } foreach (var ravenDbServer in servers) { Assert.True(2 == ravenDbServer.Server.NumberOfRequests, string.Format("Server at port: {0}. Requests: #{1}", ravenDbServer.SystemDatabase.Configuration.Port, ravenDbServer.Server.NumberOfRequests)); } }
public async Task AsyncQuery_WithWhereClause() { using (GetNewServer()) using (var store = new DocumentStore {Url = "http://localhost:8079"}.Initialize()) { using (var session = store.OpenAsyncSession()) { await session.StoreAsync(new Dummy {Name = "oren"}); await session.SaveChangesAsync(); } using (var session = store.OpenAsyncSession()) { var results = await session.Query<Dummy>() .Customize(x => x.WaitForNonStaleResults()) .Where(x => x.Name == "oren") .ToListAsync(); Assert.Equal(1, results.Count); } } }
public void ExecutionExceptionsAreRethrown() { using (GetNewServer(port, path)) using (var shard1 = new DocumentStore { Url = "http://localhost:8079" }.Initialize()) using (var session = shard1.OpenAsyncSession()) { var parallelShardAccessStrategy = new ParallelShardAccessStrategy(); Assert.Throws<ApplicationException>(() => parallelShardAccessStrategy.ApplyAsync<object>(new[] { shard1.AsyncDatabaseCommands }, new ShardRequestData(), (x, i) => { throw new ApplicationException(); }).Wait()); } }
public async Task AsyncLoadNonExistant() { // load a non-existant entity using (GetNewServer()) using (var store = new DocumentStore {Url = "http://localhost:8079"}.Initialize()) using (var session = store.OpenAsyncSession()) { var loaded = await session.LoadAsync<Dummy>("dummies/-1337"); Assert.Null(loaded); } }
private static void RegisterRavenDB(Container container) { var store = new DocumentStore { ConnectionStringName = "Server" }; store.Initialize(); container.RegisterSingle<IDocumentStore>(store); container.RegisterPerWebRequest<IAsyncDocumentSession>(() => store.OpenAsyncSession()); container.RegisterPerWebRequest<IDocumentSession>(() => store.OpenSession()); }
public async Task AsyncQuery() { using (GetNewServer()) using (var store = new DocumentStore {Url = "http://localhost:8079"}.Initialize()) using (var session = store.OpenAsyncSession()) { var results = await session.Query<Dummy>().ToListAsync(); Assert.Equal(0, results.Count); var results2 = await session.Query<Dummy>().ToListAsync(); Assert.Equal(0, results2.Count); } }
private static async Task DoTestAsync(DocumentStore store, int index) { using (var session = store.OpenAsyncSession()) { await session.StoreAsync(new User { FirstName = "name-" + index, LastName = "last" }); await session.SaveChangesAsync(); } }
public void Can_put_and_load_documet() { using (var store = new DocumentStore { Url = "http://localhost:8080" }.Initialize()) { using (var session = store.OpenAsyncSession()) { session.Store(new Item {Name = "Ayende", Id = "abc"}); session.SaveChangesAsync().Wait(); } using (var session = store.OpenAsyncSession()) { var loadAsync = session.LoadAsync<dynamic>("abc"); Assert.AreEqual("Ayende", loadAsync.Result.Name); } } }
public IEnumerable<Task> CanInsertAsyncAndDeleteAsync() { var dbname = GenerateNewDatabaseName(); using (var documentStore = new DocumentStore {Url = Url + Port}.Initialize()) { yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname); var entity = new Company {Name = "Async Company #1", Id = "companies/1"}; using (var session = documentStore.OpenAsyncSession(dbname)) { session.Store(entity); yield return session.SaveChangesAsync(); } using (var for_loading = documentStore.OpenAsyncSession(dbname)) { var loading = for_loading.LoadAsync<Company>(entity.Id); yield return loading; Assert.IsNotNull(loading.Result); } using (var for_deleting = documentStore.OpenAsyncSession(dbname)) { var loading = for_deleting.LoadAsync<Company>(entity.Id); yield return loading; for_deleting.Delete(loading.Result); yield return for_deleting.SaveChangesAsync(); } using (var for_verifying = documentStore.OpenAsyncSession(dbname)) { var verification = for_verifying.LoadAsync<Company>(entity.Id); yield return verification; Assert.IsNull(verification.Result); } } }
public void NullResultIsNotAnException() { using(GetNewServer(port, path)) using (var shard1 = new DocumentStore { Url = "http://localhost:8079" }.Initialize()) using (var session = shard1.OpenAsyncSession()) { var results = new ParallelShardAccessStrategy().ApplyAsync(new[] { shard1.AsyncDatabaseCommands }, new ShardRequestData(), (x, i) => CompletedTask.With((IList<Company>)null).Task).Result; Assert.Equal(1, results.Length); Assert.Null(results[0]); } }
public void WithAsynchronousApiIdsAreGeneratedOnStoreAsync() { using (GetNewServer()) using (var store = new DocumentStore { Url = "http://localhost:8079" }.Initialize()) using (var session = store.OpenAsyncSession()) { var obj = new TestObject { Name = "Test object" }; session.StoreAsync(obj).Wait(); Assert.NotNull(obj.Id); } }
public void When_replicating_can_do_read_striping() { var store1 = CreateStore(); var store2 = CreateStore(); var store3 = CreateStore(); using (var session = store1.OpenAsyncSession()) { session.Store(new Company()); session.SaveChangesAsync().Wait(); } SetupReplication(store1.DatabaseCommands, store2.Url, store3.Url); WaitForDocument(store2.DatabaseCommands, "companies/1"); WaitForDocument(store3.DatabaseCommands, "companies/1"); using(var store = new DocumentStore { Url = store1.Url, Conventions = { FailoverBehavior = FailoverBehavior.ReadFromAllServers } }) { store.Initialize(); var replicationInformerForDatabase = store.GetReplicationInformerForDatabase(); replicationInformerForDatabase.UpdateReplicationInformationIfNeeded((ServerClient) store.DatabaseCommands) .Wait(); Assert.Equal(2, replicationInformerForDatabase.ReplicationDestinations.Count); foreach (var ravenDbServer in servers) { ravenDbServer.Server.ResetNumberOfRequests(); } for (int i = 0; i < 6; i++) { using(var session = store.OpenAsyncSession()) { Assert.NotNull(session.LoadAsync<Company>("companies/1").Result); } } } foreach (var ravenDbServer in servers) { Assert.Equal(2, ravenDbServer.Server.NumberOfRequests); } }
public void Can_insert_async_and_multi_get_async() { using (var server = GetNewServer(port, path)) { var documentStore = new DocumentStore { Url = "http://localhost:" + port }; documentStore.Initialize(); var entity1 = new Company { Name = "Async Company #1" }; var entity2 = new Company { Name = "Async Company #2" }; using (var session = documentStore.OpenAsyncSession()) { session.Store(entity1); session.Store(entity2); session.SaveChangesAsync().Wait(); } using (var session = documentStore.OpenAsyncSession()) { var task = session.MultiLoadAsync<Company>(new[]{entity1.Id, entity2.Id}); Assert.Equal(entity1.Name, task.Result[0].Name); Assert.Equal(entity2.Name, task.Result[1].Name); } } }
public void CanChangeConventionJustForOneType_Async() { using(GetNewServer()) using (var store = new DocumentStore{Url = "http://localhost:8079"}.Initialize()) { store.Conventions.RegisterAsyncIdConvention<User>((dbName, cmds, user) => new CompletedTask<string>("users/" + user.Name)); using (var session = store.OpenAsyncSession()) { var entity = new User { Name = "Ayende" }; session.Store(entity); session.SaveChangesAsync().Wait(); Assert.Equal("users/Ayende", session.Advanced.GetDocumentId(entity)); } } }
public void CanFailoverReplicationBetweenTwoMultiTenantDatabases() { var store1 = CreateStore(); var store2 = CreateStore(); store1.DatabaseCommands.EnsureDatabaseExists("FailoverTest"); store2.DatabaseCommands.EnsureDatabaseExists("FailoverTest"); SetupReplication(store1.DatabaseCommands.ForDatabase("FailoverTest"), store2.Url + "/databases/FailoverTest"); using (var store = new DocumentStore { DefaultDatabase = "FailoverTest", Url = store1.Url, Conventions = { FailoverBehavior = FailoverBehavior.AllowReadsFromSecondariesAndWritesToSecondaries } }) { store.Initialize(); var replicationInformerForDatabase = store.GetReplicationInformerForDatabase(null); replicationInformerForDatabase.UpdateReplicationInformationIfNeeded((ServerClient) store.DatabaseCommands) .Wait(); using (var session = store.OpenAsyncSession()) { session.Store(new Item {}); session.SaveChangesAsync().Wait(); } WaitForDocument(store2.DatabaseCommands.ForDatabase("FailoverTest"), "items/1"); servers[0].Dispose(); using (var session = store.OpenAsyncSession()) { var load = session.LoadAsync<Item>("items/1").Result; Assert.NotNull(load); } } }