public void TestValueIndexMultipleValues()
{
CreateDocument(1, 2, 3, 4, 5);
CreateDocument(6, 7, 8, 9, 10);
var aggregateModel = new AggregateModel();
aggregateModel.RegisterModel();
var input = AggregateModel.CreateInput("numbers");
var sumPrediction = Function.Prediction(aggregateModel.Name, input).Property("sum");
var avgPrediction = Function.Prediction(aggregateModel.Name, input).Property("avg");
var sumIndex = IndexBuilder.ValueIndex(ValueIndexItem.Expression(sumPrediction));
Db.CreateIndex("SumIndex", sumIndex);
var avgIndex = IndexBuilder.ValueIndex(ValueIndexItem.Expression(avgPrediction));
Db.CreateIndex("AvgIndex", avgIndex);
using (var q = QueryBuilder.Select(SelectResult.Expression(sumPrediction).As("s"),
SelectResult.Expression(avgPrediction).As("a"))
.From(DataSource.Database(Db))
.Where(sumPrediction.LessThanOrEqualTo(Expression.Int(15)).Or(avgPrediction.EqualTo(Expression.Int(8))))) {
var explain = q.Explain();
explain.IndexOf("USING INDEX SumIndex").Should().NotBe(-1, "because the sum index should be used");
explain.IndexOf("USING INDEX AvgIndex").Should().NotBe(-1, "because the average index should be used");
var numRows = VerifyQuery(q, (n, r) =>
{
r.Should().Match <Result>(x => x.GetLong(0) == 15 || x.GetLong(1) == 8);
});
numRows.Should().Be(2);
}
}
public void TestCreateIndex()
{
Db.GetIndexes().Should().BeEmpty();
var fName = Expression.Property("firstName");
var lName = Expression.Property("lastName");
var fNameItem = ValueIndexItem.Property("firstName");
var lNameItem = ValueIndexItem.Expression(lName);
var index1 = IndexBuilder.ValueIndex(fNameItem, lNameItem);
Db.CreateIndex("index1", index1);
var detailItem = FullTextIndexItem.Property("detail");
var index2 = IndexBuilder.FullTextIndex(detailItem);
Db.CreateIndex("index2", index2);
var detailItem2 = FullTextIndexItem.Property("es-detail");
var index3 = IndexBuilder.FullTextIndex(detailItem2).IgnoreAccents(true).SetLanguage("es");
Db.CreateIndex("index3", index3);
Db.GetIndexes().ShouldBeEquivalentTo(new[] { "index1", "index2", "index3" });
}
public void TestValueIndex()
{
CreateDocument(1, 2, 3, 4, 5);
CreateDocument(6, 7, 8, 9, 10);
var aggregateModel = new AggregateModel();
aggregateModel.RegisterModel();
var input = AggregateModel.CreateInput("numbers");
var sumPrediction = Function.Prediction(aggregateModel.Name, input).Property("sum");
var index = IndexBuilder.ValueIndex(ValueIndexItem.Expression(sumPrediction));
Db.CreateIndex("SumIndex", index);
using (var q = QueryBuilder.Select(SelectResult.Property("numbers"),
SelectResult.Expression(sumPrediction))
.From(DataSource.Database(Db))
.Where(sumPrediction.EqualTo(Expression.Int(15)))) {
q.Explain().IndexOf("USING INDEX SumIndex").Should()
.NotBe(-1, "because the query should make use of the index");
var numRows = VerifyQuery(q, (n, r) =>
{
var numbers = r.GetArray(0).Cast <long>().ToList();
var sum = r.GetLong(1);
sum.Should().Be(numbers.Sum());
});
numRows.Should().Be(1);
aggregateModel.NumberOfCalls.Should().Be(2,
"because the value should be cached and not call the prediction function again");
}
}
public void CreateView(string fieldName, string indexName)
{
CheckOpenedConnection();
var viewName = CollectionName + "-" + fieldName; // view name = collectionName-fieldName
database.CreateIndex(viewName, IndexBuilder.ValueIndex(items: ValueIndexItem.Property(fieldName)));
}
public void TestCreateSameIndexTwice()
{
var item = ValueIndexItem.Expression(Expression.Property("firstName"));
var index = IndexBuilder.ValueIndex(item);
Db.CreateIndex("myindex", index);
Db.CreateIndex("myindex", index);
Db.GetIndexes().ShouldBeEquivalentTo(new[] { "myindex" });
}
private void CreateArtistsIndex()
{
_indexArtistsBench.Start();
var collation = Collation.Unicode().IgnoreCase(true).IgnoreAccents(true);
var artist = Expression.Property("Artist").Collate(collation);
var comp = Expression.Property("Compilation");
var index = Index.ValueIndex().On(ValueIndexItem.Expression(artist), ValueIndexItem.Expression(comp));
Db.CreateIndex("byArtist", index);
_indexArtistsBench.Stop();
}
private static void CreateIndex()
{
var db = _Database;
// # tag::query-index[]
// For value types, this is optional but provides performance enhancements
var index = IndexBuilder.ValueIndex(
ValueIndexItem.Expression(Expression.Property("type")),
ValueIndexItem.Expression(Expression.Property("name")));
db.CreateIndex("TypeNameIndex", index);
// # end::query-index[]
}
private void CreateDatabaseIndexes(Database db)
{
// For searches on type property
db.CreateIndex("type", IndexBuilder.ValueIndex(ValueIndexItem.Expression(Expression.Property("type"))));
// For full text searches on airports and hotels
db.CreateIndex("airportName",
IndexBuilder.FullTextIndex(FullTextIndexItem.Property("airportname")));
db.CreateIndex("description",
IndexBuilder.FullTextIndex(FullTextIndexItem.Property("description")));
db.CreateIndex("name",
IndexBuilder.FullTextIndex(FullTextIndexItem.Property("name")));
}
public List <string> Create(Database database)
{
List <string> indexes = database.GetIndexes().ToList <string>();
if (!indexes.Contains("TableI2"))
{
database.CreateIndex("TableI2", Index.ValueIndex(ValueIndexItem.Expression(Expression.Property("table"))));
}
if (!indexes.Contains("VilleI1"))
{
database.CreateIndex("VilleI1", Index.ValueIndex(ValueIndexItem.Expression(Expression.Property("ville"))));
}
return(database.GetIndexes().ToList <string>());
}
private static void UsePredictiveModel()
{
using (var db = new Database("mydb")) {
// tag::register-model[]
var model = new ImageClassifierModel();
Database.Prediction.RegisterModel("ImageClassifier", model);
// end::register-model[]
// tag::predictive-query-value-index[]
var index = IndexBuilder.ValueIndex(ValueIndexItem.Property("label"));
db.CreateIndex("value-index-image-classifier", index);
// end::predictive-query-value-index[]
// tag::unregister-model[]
Database.Prediction.UnregisterModel("ImageClassifier");
// end::unregister-model[]
}
}
private void SetupQuery()
{
_db.CreateIndex("byName", IndexBuilder.ValueIndex(ValueIndexItem.Expression(Expression.Property("name"))));
_filteredQuery = QueryBuilder.Select(SelectResult.Expression(Meta.ID),
SelectResult.Expression(Expression.Property("name")))
.From(DataSource.Database(_db))
.Where(Expression.Property("name")
.Like(Expression.Parameter("searchText"))
.And(Expression.Property("type").EqualTo(Expression.String("task-list"))))
.OrderBy(Ordering.Property("name"));
_fullQuery = QueryBuilder.Select(SelectResult.Expression(Meta.ID),
SelectResult.Expression(Expression.Property("name")))
.From(DataSource.Database(_db))
.Where(Expression.Property("name")
.NotNullOrMissing()
.And(Expression.Property("type").EqualTo(Expression.String("task-list"))))
.OrderBy(Ordering.Property("name"));
_incompleteQuery = QueryBuilder.Select(SelectResult.Expression(Expression.Property("taskList.id")),
SelectResult.Expression(Function.Count(Expression.All())))
.From(DataSource.Database(_db))
.Where(Expression.Property("type").EqualTo(Expression.String(TasksModel.TaskType))
.And(Expression.Property("complete").EqualTo(Expression.Boolean(false))))
.GroupBy(Expression.Property("taskList.id"));
_incompleteQuery.AddChangeListener((sender, args) =>
{
_incompleteCount.Clear();
foreach (var result in args.Results)
{
_incompleteCount[result.GetString(0)] = result.GetInt(1);
}
foreach (var row in TasksList)
{
row.IncompleteCount = _incompleteCount.ContainsKey(row.DocumentID)
? _incompleteCount[row.DocumentID]
: 0;
}
});
}
public void TestValueIndexCompoundValues()
{
CreateDocument(1, 2, 3, 4, 5);
CreateDocument(6, 7, 8, 9, 10);
var aggregateModel = new AggregateModel();
aggregateModel.RegisterModel();
var input = Expression.Dictionary(new Dictionary <string, object>
{
["numbers"] = Expression.Property("numbers")
});
var sumPrediction = Function.Prediction(aggregateModel.Name, input).Property("sum");
var avgPrediction = Function.Prediction(aggregateModel.Name, input).Property("avg");
var index = IndexBuilder.ValueIndex(ValueIndexItem.Expression(sumPrediction),
ValueIndexItem.Expression(avgPrediction));
Db.CreateIndex("SumAvgIndex", index);
aggregateModel.AllowCalls = false;
using (var q = QueryBuilder.Select(SelectResult.Expression(sumPrediction).As("s"),
SelectResult.Expression(avgPrediction).As("a"))
.From(DataSource.Database(Db))
.Where(sumPrediction.EqualTo(Expression.Int(15)).And(avgPrediction.EqualTo(Expression.Int(3))))) {
var explain = q.Explain();
explain.IndexOf("USING INDEX SumAvgIndex").Should().NotBe(-1, "because the sum index should be used");
var numRows = VerifyQuery(q, (n, r) =>
{
r.GetLong(0).Should().Be(15);
r.GetLong(1).Should().Be(3);
});
numRows.Should().Be(1);
aggregateModel.NumberOfCalls.Should().Be(4);
}
}
public void TestCreateSameNameIndexes()
{
var fName = Expression.Property("firstName");
var lName = Expression.Property("lastName");
var fNameItem = ValueIndexItem.Expression(fName);
var fNameIndex = IndexBuilder.ValueIndex(fNameItem);
Db.CreateIndex("myindex", fNameIndex);
var lNameItem = ValueIndexItem.Expression(lName);
var lNameIndex = IndexBuilder.ValueIndex(lNameItem);
Db.CreateIndex("myindex", lNameIndex);
Db.GetIndexes().ShouldBeEquivalentTo(new[] { "myindex" }, "because lNameIndex should overwrite fNameIndex");
var detailItem = FullTextIndexItem.Property("detail");
var detailIndex = IndexBuilder.FullTextIndex(detailItem);
Db.CreateIndex("myindex", detailIndex);
Db.GetIndexes().ShouldBeEquivalentTo(new[] { "myindex" }, "because detailIndex should overwrite lNameIndex");
}
public static IEnumerable <BenchmarkResult> Start()
{
var databaseName = "Test";
Console.WriteLine($"--- Benchmark Start ---");
var stopWatch = new Stopwatch();
// STEP 1: DELETE DB
var database = new Database(databaseName);
database.Delete();
database.Close();
var deleteDBResult = new BenchmarkResult("Delete DB", stopWatch.Elapsed);
Log(deleteDBResult);
stopWatch.Restart();
// STEP 2: NEW DB
stopWatch.Start();
database = new Database(databaseName);
var newDBResult = new BenchmarkResult("Create New DB", stopWatch.Elapsed);
Log(newDBResult);
stopWatch.Restart();
// STEP 3: ENSURE INDEXES
var indexes = new HashSet <string>
{
ICouchbaseDocumentExtensions.JsonProperties.CouchbaseId,
ICouchbaseDocumentExtensions.JsonProperties.CouchbaseType,
IPerishableDataExtensions.JsonProperties.LastUpdated,
IPerishableDataExtensions.JsonProperties.ExpirationDate,
nameof(PersonObfuscated.EntryGuid),
nameof(PersonObfuscated.FirstName),
nameof(PersonObfuscated.LastName),
nameof(PersonObfuscated.DisplayName),
nameof(PersonObfuscated.SiteName),
nameof(PersonObfuscated.DepartmentName),
nameof(PersonObfuscated.TeamName),
};
foreach (var index in indexes)
{
var indexName = $"ValueIndex_{index}";
database.CreateIndex(indexName, IndexBuilder.ValueIndex(ValueIndexItem.Expression(Expression.Property(indexName))));
}
var createIndexes = new BenchmarkResult($"Create {indexes.Count} Indexes", stopWatch.Elapsed);
Log(createIndexes);
stopWatch.Restart();
// STEP 4: CREATE MODELS
var numberOfDocuments = 11000;
var entryType = "entryType";
var firstName = "John";
var lastName = "Smith";
var maidenName = "maidenName";
var displayName = "John Smith";
var organizationName = "John Smith";
var locationGuid = Guid.NewGuid();
var siteGuid = Guid.NewGuid();
var siteName = "Main Site";
var userStatus = "Regular User";
var departmentName = "Information Technology > Apps";
var residenceArea = "Anytown - PA (USA)";
var workAreaName = "Office 1";
var teamName = "Blue Team";
var contacts = new List <Contact>
{
new Contact(ContactType.Work, ContactMethod.Phone, "12345"),
new Contact(ContactType.Work, ContactMethod.Fax, "12345"),
new Contact(ContactType.Personal, ContactMethod.Mobile, "+1 8885551212"),
new Contact(ContactType.Personal, ContactMethod.Email, "*****@*****.**"),
new Contact(ContactType.Work, ContactMethod.Email, "*****@*****.**")
};
var spouseEntryGuid = Guid.NewGuid();
var personPrimaryPhotoGuid = Guid.NewGuid();
string primaryPhotoUrl = "https://myphotoserver.blob.core.windows.net/primaryphotos/8891be56-47c6-4546-8954-9116743f2efc?sv=2018-03-28&sr=b&sig=vJTpHXMYefdVrehAo%2FJiDHNnq60rMlwk3d4QHZQSRmk%3D&se=2019-11-15T23%3A00%3A48Z&sp=r";
var emergencyContactGuids = new List <Guid> {
};
var lastUpdated = DateTimeOffset.Now;
var expirationDate = DateTimeOffset.Now;
var models = new PersonObfuscated[numberOfDocuments];
for (int i = 0; i < numberOfDocuments; i++)
{
var entryGuid = Guid.NewGuid();
var person = new PersonObfuscated(
entryGuid,
entryType,
firstName,
lastName,
maidenName,
displayName,
organizationName,
locationGuid,
siteGuid,
siteName,
userStatus,
departmentName,
residenceArea,
workAreaName,
teamName,
contacts,
spouseEntryGuid,
personPrimaryPhotoGuid,
primaryPhotoUrl,
emergencyContactGuids,
lastUpdated,
expirationDate);
models[i] = person;
}
var createModels = new BenchmarkResult($"Create {models.Length} Models", stopWatch.Elapsed);
Log(createModels);
stopWatch.Restart();
// STEP 5: CREATE MUTABLE DOCUMENTS
var documents = models.AsParallel().Select(model => model.ToMutableDocument()).ToArray();
var createDocuments = new BenchmarkResult($"Create {documents.Length} Documents", stopWatch.Elapsed);
Log(createDocuments);
stopWatch.Restart();
// STEP 6: INSERT INTO COUCHBASE
database.InBatch(() =>
{
foreach (var doc in documents)
{
database.Save(doc);
}
});
var batchSaveDocuments = new BenchmarkResult($"Batch Save {documents.Length} Documents", stopWatch.Elapsed);
Log(batchSaveDocuments);
stopWatch.Restart();
database.Close();
Console.WriteLine($"--- Benchmark End ---");
return(new BenchmarkResult[]
{
deleteDBResult,
newDBResult,
createIndexes,
createModels,
createDocuments,
batchSaveDocuments
});
}
