public IEnumerable<Task> Can_perform_a_simple_where()
		{
			var dbname = GenerateNewDatabaseName();
			var documentStore = new DocumentStore { Url = Url + Port };
			documentStore.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> Can_get_total_count()
		{
			var dbname = GenerateNewDatabaseName();
			var documentStore = new DocumentStore { Url = Url + Port };
			documentStore.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 IEnumerable<Task> Including_a_related_entity_should_avoid_hitting_the_server_twice()
		{
			var dbname = GenerateNewDatabaseName();
			var documentStore = new DocumentStore { Url = Url + Port };
			documentStore.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")
					.QueryResultAsync;
				yield return query;

				Assert.Equal("Hello", query.Result.Results[0].Value<string>("Note"));

				// NOTE: this call should not hit the server 
				var load = session.LoadAsync<Customer>(customer.Id);
				yield return load;

				Assert.Equal(1, session.Advanced.NumberOfRequests);
			}
		}
		public IEnumerable<Task> Can_test_two_conditions_in_a_where_clause()
		{
			var dbname = GenerateNewDatabaseName();
			var documentStore = new DocumentStore { Url = Url + Port };
			documentStore.Initialize();
			yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname);

			using (var session = documentStore.OpenAsyncSession(dbname))
			{
				session.Store(new Company { Name = "Async Company", Phone = 55555, Id = "companies/1" });
				session.Store(new Company { Name = "Async Company", Phone = 12345, Id = "companies/2" });
				yield return session.SaveChangesAsync();
			}

			using (var session = documentStore.OpenAsyncSession(dbname))
			{
				var query = session.Query<Company>()
							.Where(x => x.Name == "Async Company" && x.Phone == 12345)
							.ToListAsync();
				yield return query;

				Assert.AreEqual(1, query.Result.Count);
				Assert.AreEqual(12345, query.Result[0].Phone);
			}
		}
Beispiel #5
0
        internal override PreparedDatabaseCommand Prepare(DocumentStore store, Guid etag, int uniqueParameterIdentifier)
        {
            var values = ConvertAnonymousToProjections(table, projections);

            values[table.EtagColumn] = etag;
            values[table.ModifiedAtColumn] = DateTimeOffset.Now;

            var sql = new SqlBuilder()
                .Append("update {0} set {1} where {2}=@Id{3}",
                        store.Database.FormatTableNameAndEscape(table.Name),
                        string.Join(", ", from column in values.Keys select column.Name + "=@" + column.Name + uniqueParameterIdentifier),
                        table.IdColumn.Name,
                        uniqueParameterIdentifier)
                .Append(!lastWriteWins, "and {0}=@CurrentEtag{1}",
                        table.EtagColumn.Name,
                        uniqueParameterIdentifier)
                .ToString();

            var parameters = MapProjectionsToParameters(values, uniqueParameterIdentifier);
            AddTo(parameters, "@Id" + uniqueParameterIdentifier, key, SqlTypeMap.Convert(table.IdColumn).DbType, null);

            if (!lastWriteWins)
            {
                AddTo(parameters, "@CurrentEtag" + uniqueParameterIdentifier, currentEtag, SqlTypeMap.Convert(table.EtagColumn).DbType, null);
            }

            return new PreparedDatabaseCommand
            {
                Sql = sql,
                Parameters = parameters.Values.ToList(),
                ExpectedRowCount = 1
            };
        }
Beispiel #6
0
		public IEnumerable<Task> Can_delete_an_attachment()
		{
			var store = new DocumentStore {Url = Url + Port};
			store.Initialize();

			var dbname = GenerateNewDatabaseName();
			yield return store.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname);

			const string someData = "The quick brown fox jumps over the lazy dog";
			var encoding = new UTF8Encoding();
			var bytes = encoding.GetBytes(someData);

			yield return store.AsyncDatabaseCommands
				.ForDatabase(dbname)
				.PutAttachmentAsync("123", Guid.Empty, bytes, null);

			yield return store.AsyncDatabaseCommands
				.ForDatabase(dbname)
				.DeleteAttachmentAsync("123", null);

			var get = store.AsyncDatabaseCommands
				.ForDatabase(dbname)
				.GetAttachmentAsync("123");
			yield return get;
			
			Assert.AreEqual(null, get.Result);
		}
Beispiel #7
0
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);

            var estore = new EventStore();
            var dstore = new DocumentStore();

            Action<Command> future = cmd => DiContainer.Current.CommandBus.Submit(cmd);

            DiContainer.Current = new DiContainer
                                      {
                                          Store = estore,
                                          DocumentStore = dstore,
                                          CommandBus = new CommandDispatcher(
                                              estore,
                                              e => estore.Store(e),
                                              future
                                              ),
                                          Projektor = new Projektor(estore, dstore)
                                      };

            if (!estore.All.Any()) GenerateDemoData(estore);
        }
Beispiel #8
0
        internal override PreparedDatabaseCommand Prepare(DocumentStore store, Guid etag, int uniqueParameterIdentifier)
        {
            var sql = new SqlBuilder()
                .Append("delete from {0} where {1} = @Id{2}",
                        store.Database.FormatTableNameAndEscape(table.Name),
                        table.IdColumn.Name,
                        uniqueParameterIdentifier)
                .Append(!lastWriteWins,
                        "and {0} = @CurrentEtag{1}",
                        table.EtagColumn.Name,
                        uniqueParameterIdentifier)
                .ToString();

            var parameters = new Dictionary<string, Parameter>();
            AddTo(parameters, "@Id" + uniqueParameterIdentifier, key, SqlTypeMap.Convert(table.IdColumn).DbType, null);

            if (!lastWriteWins)
            {
                AddTo(parameters, "@CurrentEtag" + uniqueParameterIdentifier, currentEtag, SqlTypeMap.Convert(table.EtagColumn).DbType, null);
            }

            return new PreparedDatabaseCommand
            {
                Sql = sql,
                Parameters = parameters.Values.ToList(),
                ExpectedRowCount = 1
            };
        }
Beispiel #9
0
        internal override PreparedDatabaseCommand Prepare(DocumentStore store, Guid etag, int uniqueParameterIdentifier)
        {
            var name = string.Format("{0}_{1}_{2}.bak", design.DocumentType.FullName, key, version);
            writer.Write(name, document);

            return command.Prepare(store, etag, uniqueParameterIdentifier);
        }
		public IEnumerable<Task> Should_not_cache_the_list_of_databases()
		{
			var documentStore = new DocumentStore { Url = Url + Port };
			documentStore.Initialize();

			var first = GenerateNewDatabaseName();
			yield return documentStore.AsyncDatabaseCommands
				.EnsureDatabaseExistsAsync(first);

			var task = documentStore.AsyncDatabaseCommands
				.GetDatabaseNamesAsync();
			yield return task;

			Assert.IsTrue(task.Result.Contains(first));

			var second = GenerateNewDatabaseName();
			yield return documentStore.AsyncDatabaseCommands
				.EnsureDatabaseExistsAsync(second);

			var verify = documentStore.AsyncDatabaseCommands
				.GetDatabaseNamesAsync();
			yield return verify;

			Assert.IsTrue(verify.Result.Contains(second));
		}
Beispiel #11
0
		public IEnumerable<Task> Some_sample_data()
		{
			var store = new DocumentStore {Url = Url + Port};
			store.Initialize();

			using (var session = store.OpenAsyncSession())
			{
				Enumerable.Range(0, 25).ToList()
					.ForEach(i => session.Store(new Company {Id = "Companies/" + i, Name = i.ToString()}));

				Enumerable.Range(0, 250).ToList()
					.ForEach(i => session.Store(new Order { Id = "Orders/" + i, Note = i.ToString() }));

				Enumerable.Range(0, 100).ToList()
					.ForEach(i => session.Store(new Customer { Name = "Joe " + i}));

				Enumerable.Range(0, 75).ToList()
					.ForEach(i => session.Store(new Contact { FirstName = "Bob" + i, Surname = i.ToString() + "0101001" }));

				session.Store(new Customer { Name = "Henry"});
				session.Store(new Order { Note = "An order" });
				session.Store(new Company {Name = "My Company"});

				yield return session.SaveChangesAsync();
			}
		}
        public IEnumerable<Task> Can_insert_async_and_multi_get_async()
        {
            var dbname = GenerateNewDatabaseName();
            var documentStore = new DocumentStore {Url = Url + Port};
            documentStore.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.MultiLoadAsync<Company>(new[] {entity1.Id, entity2.Id});
                yield return task;

                Assert.Equal(entity1.Name, task.Result[0].Name);
                Assert.Equal(entity2.Name, task.Result[1].Name);
            }
        }
Beispiel #13
0
		public IEnumerable<Task> Can_delete_an_index_async()
		{
			var dbname = GenerateNewDatabaseName();
			var documentStore = new DocumentStore {Url = Url + Port};
			documentStore.Initialize();
			yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname);

			yield return documentStore.AsyncDatabaseCommands
				.ForDatabase(dbname)
				.PutIndexAsync("Test", new IndexDefinition
				                       	{
				                       		Map = "from doc in docs.Companies select new { doc.Name }"
				                       	}, true);

			var verify_put = documentStore.AsyncDatabaseCommands
				.ForDatabase(dbname)
				.GetIndexNamesAsync(0, 25);
			yield return verify_put;

			Assert.IsTrue(verify_put.Result.Contains("Test"));

			yield return documentStore.AsyncDatabaseCommands
				.ForDatabase(dbname)
				.DeleteIndexAsync("Test");

			var verify_delete = documentStore.AsyncDatabaseCommands
				.ForDatabase(dbname)
				.GetIndexNamesAsync(0, 25);
			yield return verify_delete;

			//NOTE: this is failing because Silverlight is caching the response from the first verification
			Assert.IsFalse(verify_delete.Result.Contains("Test"));
		}
Beispiel #14
0
        public void SetUp()
        {
            var path = Path.Combine(Environment.CurrentDirectory, GetType().Name + "Test");
            EnsurePath(path);

            DocumentStore = new DocumentStore(path);
        }
Beispiel #15
0
		public Replication()
		{
			var store = new DocumentStore();

			DocumentConvention Conventions = store.Conventions;

			#region failover_behavior
			Conventions.FailoverBehavior = FailoverBehavior.AllowReadsFromSecondaries;
            #endregion

            #region cluster_failover_behavior
            Conventions.FailoverBehavior = FailoverBehavior.ReadFromAllWriteToLeader;
            #endregion

            #region replication_informer
            Conventions.ReplicationInformerFactory = (url, jsonRequestFactory, requestTimeMetricGetter) =>
				new ReplicationInformer(Conventions, jsonRequestFactory, requestTimeMetricGetter);
			#endregion

			#region index_and_transformer_replication_mode
			Conventions.IndexAndTransformerReplicationMode = IndexAndTransformerReplicationMode.Indexes |
			                                                 IndexAndTransformerReplicationMode.Transformers;
			#endregion

		} 
Beispiel #16
0
		public Querying()
		{
			var store = new DocumentStore();

			DocumentConvention Conventions = store.Conventions;

			#region find_prop_name
			Conventions.FindPropertyNameForIndex = (indexedType, indexName, path, prop) => (path + prop).Replace(",", "_").Replace(".", "_");
			Conventions.FindPropertyNameForDynamicIndex = (indexedType, indexName, path, prop) => path + prop;
			#endregion

			#region querying_consistency
			Conventions.DefaultQueryingConsistency = ConsistencyOptions.None;
			#endregion

			#region querying_consistency_2
			Conventions.DefaultQueryingConsistency = ConsistencyOptions.AlwaysWaitForNonStaleResultsAsOfLastWrite;
			#endregion

			#region apply_reduce_func
			Conventions.ApplyReduceFunction = (type, resultType, results, transformResults) => 
				// carry out the reduction over results from different shards
			#endregion
				null;

			#region allow_queries_on_id
			Conventions.AllowQueriesOnId = false;
			#endregion
		} 
Beispiel #17
0
		public DtcTransactions()
		{
			var store = new DocumentStore();

			using (var session = store.OpenSession())
			{
				#region transaction_scope_usage
				using (var transaction = new TransactionScope())
				{
					Employee employee = session.Load<Employee>("employees/1");

					employee.FirstName = "James";

					session.SaveChanges(); // will create HTTP request

					session.Delete(employee);

					session.SaveChanges(); // will create HTTP request

					transaction.Complete(); // will commit the transaction
				}

				#endregion
			}

			#region default_transaction_recovery_storage
			store.TransactionRecoveryStorage = new VolatileOnlyTransactionRecoveryStorage();
			#endregion

			#region local_directory_transaction_recovery_storage
			store.TransactionRecoveryStorage = new LocalDirectoryTransactionRecoveryStorage(@"C:\tx_recovery_data");
			#endregion
		}
Beispiel #18
0
        public static void Configure(PhoneApplicationFrame rootFrame)
        {
            DocumentStore = new DocumentStore();
            Container = new Container();

            Container.Register<IDocumentStore>(c => new DocumentStore());
            Container.Register<IBus>(c => new Bus(c));

            Container.Register(c => new ActivityNewActivityHandler { Bus = c.Resolve<IBus>(), DocumentStore = DocumentStore });
            Container.Register(c => new TestModeActivatedHandler { Bus = c.Resolve<IBus>() });
            Container.Register(c => new ActivateTestModeHandler { Bus = c.Resolve<IBus>() });
            Container.Register(c => new ClearCacheHandler { DocumentStore = c.Resolve<IDocumentStore>() });
            Container.Register(c => new Contexts.Review.Domain.ClearCacheHandler { DocumentStore = c.Resolve<IDocumentStore>() });

            var bus = Container.Resolve<IBus>();

            bus.RegisterHandler<ActivityNewActivityHandler, NewActivityEvent>();
            bus.RegisterHandler<TestModeActivatedHandler, TestModeActivatedEvent>();
            bus.RegisterHandler<ActivateTestModeHandler, ActivateCommand>();
            bus.RegisterHandler<Contexts.Settings.ClearCacheHandler, ClearCacheCommand>();
            bus.RegisterHandler<Contexts.Review.Domain.ClearCacheHandler, ClearCacheCommand>();

            Contexts.Import.Module.Configure(Container);
            Contexts.Import.ModuleUi.Configure(Container, rootFrame);

            Contexts.Review.Module.Confiure(Container);
        }
		public WhatAreConventions()
		{
			var store = new DocumentStore();

			#region conventions_1
			DocumentConvention conventions = store.Conventions;
			#endregion
		}
Beispiel #20
0
		void InitializeSession()
		{
			var store = new DocumentStore { Url = Address };

			store.Initialize();

			Session = store.OpenAsyncSession();
		}
 public ProjectionStore(string parentDirectory, IEnumerable<Projection> projections, DocumentStore documentStore)
 {
     return;
     _parentDirectory = parentDirectory;
     _documentStore = documentStore;
     _projections = projections.ToList();
     _projections.ForEach(x => CollectionChanged(x.InputType));
     documentStore.DocumentChanged += CollectionChanged;
 }
Beispiel #22
0
        public void ShouldCreateADocumentStoreBackendFile()
        {
            Assert.IsFalse(File.Exists(storePath));

            var store = new DocumentStore(storePath);
            store.Close();

            Assert.IsTrue(File.Exists(storePath));
        }
			private static IDocumentStore CreateStore()
			{
				IDocumentStore store = new DocumentStore()
				{
					Url = "http://localhost:8080",
					DefaultDatabase = "Northwind"
				}.Initialize();

				return store;
			}
Beispiel #24
0
		public IEnumerable<Task> Can_retrieve_statistics_for_the_default_database()
		{
			var store = new DocumentStore { Url = Url + Port };
			store.Initialize();

			var getStats = store.AsyncDatabaseCommands
				.GetStatisticsAsync();
			yield return getStats;

			Assert.IsNotNull(getStats.Result);
		}
		public IEnumerable<Task> Can_get_a_list_of_databases_async()
		{
			var dbname = GenerateNewDatabaseName();
			var documentStore = new DocumentStore { Url = Url + Port };
			documentStore.Initialize();
			yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname);

			var task = documentStore.AsyncDatabaseCommands.GetDatabaseNamesAsync();
			yield return task;

			Assert.IsTrue(task.Result.Contains(dbname));
		}
        public void SetUp()
        {
            ConfigureRavenPersistence.AutoCreateDatabase = false;

            var config = Configure.With(new[] { GetType().Assembly })
                .DefineEndpointName("UnitTests")
                .DefaultBuilder();

            Initialize(config);

            store = config.Builder.Build<IDocumentStore>() as DocumentStore;
        }
		public CreatingDocumentStore()
		{
			#region document_store_creation
			using (IDocumentStore store = new DocumentStore()
			{
				Url = "http://localhost:8080"
			}.Initialize())
			{

			}
			#endregion
		}
Beispiel #28
0
		public BewareOf()
		{
			var store = new DocumentStore();

			using (var session = store.OpenSession())
			{
				#region session_value_types
				Employee employee = session.Load<Employee>(9); // get "employees/9"

				session.Delete<Employee>(12); // delete "employees/12"
				#endregion
			}
		} 
		public void CreateDbAndLoad()
		{
			const string DbName = "CreationTest";

			using (var documentStore = new DocumentStore { Url = "http://localhost:8080/databases/" + DbName }.Initialize())
			{
				documentStore.DatabaseCommands.EnsureDatabaseExists(DbName);

				using (var session = documentStore.OpenSession())
				{
					session.Load<Order>("1");
				}
			}
		}
		public CustomizeCollectionAssignmentForEntities()
		{
			var store = new DocumentStore();

			#region custom_collection_name
			store.Conventions.FindTypeTagName = type =>
			{
				if (typeof(Category).IsAssignableFrom(type))
					return "ProductGroups";
				
				return DocumentConvention.DefaultTypeTagName(type);
			};
			#endregion
		}