Beispiel #1
0
        public WorkingWithDocumentIdentifiers(string g)
        {
            var store   = new DocumentStore();
            var session = store.OpenSession();

            #region commands_identity_generate

            var command = new NextIdentityForCommand("products");
            session.Advanced.RequestExecutor.Execute(command, session.Advanced.Context);
            var identity = command.Result;

            var doc = new DynamicJsonValue
            {
                ["Name"] = "My RavenDB"
            };

            var blittableDoc = session.Advanced.EntityToBlittable.ConvertEntityToBlittable(doc, null);

            var putCommand = new PutDocumentCommand("products/" + identity, null, blittableDoc);

            session.Advanced.RequestExecutor.Execute(putCommand, session.Advanced.Context);

            #endregion

            #region commands_identity_set

            var seedIdentityCommand = new SeedIdentityForCommand("products", 1994);

            #endregion
        }
Beispiel #2
0
        public async Task MixedCluster_ClusterWideIdentity()
        {
            var(leader, peers, local) = await CreateMixedCluster(new[]
            {
                "4.0.6",
                "4.0.6"
            });

            var stores = await GetStores(leader, peers);

            var leaderStore = stores.Stores.Single(s => s.Urls[0] == leader.WebUrl);
            var nonLeader   = stores.Stores.First(s => s.Urls[0] != leader.WebUrl);

            using (stores.Disposable)
            {
                var dbName = await CreateDatabase(leaderStore, 3);

                await Task.Delay(500);

                using (var session = nonLeader.OpenAsyncSession(dbName))
                {
                    var command = new SeedIdentityForCommand("users", 1990);

                    await session.Advanced.RequestExecutor.ExecuteAsync(command, session.Advanced.Context);

                    var result = command.Result;

                    Assert.Equal(1990, result);
                    var user = new User
                    {
                        Name     = "Adi",
                        LastName = "Async"
                    };
                    await session.StoreAsync(user, "users|");

                    await session.SaveChangesAsync();

                    var id = session.Advanced.GetDocumentId(user);
                    Assert.Equal("users/1991", id);
                }
            }
        }
Beispiel #3
0
        public async Task ClusterWideIdentity()
        {
            var db     = "ClusterWideIdentity";
            var leader = await CreateRaftClusterAndGetLeader(2);

            await CreateDatabaseInCluster(db, 2, leader.WebUrl);

            var nonLeader = Servers.First(x => ReferenceEquals(x, leader) == false);

            using (var store = new DocumentStore
            {
                Database = db,
                Urls = new[] { nonLeader.WebUrl }
            }.Initialize())
            {
                using (var session = store.OpenAsyncSession())
                {
                    var command = new SeedIdentityForCommand("users", 1990);

                    await session.Advanced.RequestExecutor.ExecuteAsync(command, session.Advanced.Context);

                    var result = command.Result;

                    Assert.Equal(1990, result);
                    var user = new User
                    {
                        Name     = "Adi",
                        LastName = "Async"
                    };
                    await session.StoreAsync(user, "users|");

                    await session.SaveChangesAsync();

                    var id = session.Advanced.GetDocumentId(user);
                    Assert.Equal("users/1991", id);
                }
            }
        }
        public async Task SeedIdentityFor()
        {
            using (var store = GetDocumentStore())
            {
                using (var s = store.OpenSession())
                {
                    var entity = new User
                    {
                        LastName = "Adi"
                    };

                    s.Store(entity, "users|");
                    s.SaveChanges();
                }

                using (var commands = store.Commands())
                {
                    var command = new SeedIdentityForCommand("users", 1990);

                    await commands.RequestExecutor.ExecuteAsync(command, commands.Context);

                    var result = command.Result;

                    Assert.Equal(1990, result);
                }

                using (var s = store.OpenSession())
                {
                    var entity = new User
                    {
                        LastName = "Avivi"
                    };

                    s.Store(entity, "users|");
                    s.SaveChanges();
                }

                using (var s = store.OpenSession())
                {
                    var entityWithId1    = s.Load <User>("users/1");
                    var entityWithId2    = s.Load <User>("users/2");
                    var entityWithId1990 = s.Load <User>("users/1990");
                    var entityWithId1991 = s.Load <User>("users/1991");
                    var entityWithId1992 = s.Load <User>("users/1992");

                    Assert.NotNull(entityWithId1);
                    Assert.NotNull(entityWithId1991);
                    Assert.Null(entityWithId2);
                    Assert.Null(entityWithId1990);
                    Assert.Null(entityWithId1992);

                    Assert.Equal("Adi", entityWithId1.LastName);
                    Assert.Equal("Avivi", entityWithId1991.LastName);
                }

                using (var commands = store.Commands())
                {
                    var command = new SeedIdentityForCommand("users", 1975);

                    await commands.RequestExecutor.ExecuteAsync(command, commands.Context);

                    var result = command.Result;

                    Assert.Equal(1991, result);
                }
            }
        }