public void CreateMapReduceIndex()
{
var mapping = new Data.DynamicQueryMapping()
{
AggregationOperation = AggregationOperation.Count,
Items = new[]{
new DynamicQueryMappingItem(){
From = "User.Name",
To = "UserName"
}
}
};
var definition = mapping.CreateIndexDefinition();
Assert.Equal(@"from doc in docs
select new { UserName = doc.User.Name, Count = 1 }", definition.Map);
Assert.Equal(@"from result in results
group result by result.UserName
into g
select new
{
UserName = g.Key,
Count = g.Sum(x=>x.Count)
}
", definition.Reduce);
}
private QueryResult ExecuteActualQuery(IndexQuery query, DynamicQueryMapping map, Tuple<string, bool> touchTemporaryIndexResult, string realQuery)
{
// Perform the query until we have some results at least
QueryResult result;
var sp = Stopwatch.StartNew();
while (true)
{
result = documentDatabase.Query(map.IndexName,
new IndexQuery
{
Cutoff = query.Cutoff,
PageSize = query.PageSize,
Query = realQuery,
Start = query.Start,
FieldsToFetch = query.FieldsToFetch,
GroupBy = query.GroupBy,
AggregationOperation = query.AggregationOperation,
SortedFields = query.SortedFields,
});
if (!touchTemporaryIndexResult.Item2 ||
!result.IsStale ||
result.Results.Count >= query.PageSize ||
sp.Elapsed.TotalSeconds > 15)
{
return result;
}
Thread.Sleep(100);
}
}
private static void UpdateFieldNamesForSortedFields(IndexQuery query, DynamicQueryMapping map)
{
if (query.SortedFields == null) return;
foreach (var sortedField in query.SortedFields)
{
var item = map.Items.FirstOrDefault(x => x.From == sortedField.Field);
if (item != null)
sortedField.Field = item.To;
}
}
private static IndexQuery CreateIndexQuery(IndexQuery query, DynamicQueryMapping map, string realQuery)
{
var indexQuery = new IndexQuery
{
Cutoff = query.Cutoff,
WaitForNonStaleResultsAsOfNow = query.WaitForNonStaleResultsAsOfNow,
PageSize = query.PageSize,
Query = realQuery,
Start = query.Start,
FieldsToFetch = query.FieldsToFetch,
IsDistinct = query.IsDistinct,
SortedFields = query.SortedFields,
DefaultField = query.DefaultField,
CutoffEtag = query.CutoffEtag,
DebugOptionGetIndexEntries = query.DebugOptionGetIndexEntries,
DefaultOperator = query.DefaultOperator,
SkippedResults = query.SkippedResults,
HighlighterPreTags = query.HighlighterPreTags,
HighlighterPostTags = query.HighlighterPostTags,
HighlightedFields = query.HighlightedFields,
HighlighterKeyName = query.HighlighterKeyName,
ResultsTransformer = query.ResultsTransformer,
TransformerParameters = query.TransformerParameters,
ExplainScores = query.ExplainScores,
SortHints = query.SortHints,
ShowTimings = query.ShowTimings,
AllowMultipleIndexEntriesForSameDocumentToResultTransformer = query.AllowMultipleIndexEntriesForSameDocumentToResultTransformer,
DisableCaching = query.DisableCaching,
SkipDuplicateChecking = query.SkipDuplicateChecking,
WaitForNonStaleResults = query.WaitForNonStaleResults
};
if (indexQuery.SortedFields == null)
return indexQuery;
for (int index = 0; index < indexQuery.SortedFields.Length; index++)
{
var sortedField = indexQuery.SortedFields[index];
var fieldName = sortedField.Field;
bool hasRange = false;
if (fieldName.EndsWith("_Range"))
{
fieldName = fieldName.Substring(0, fieldName.Length - "_Range".Length);
hasRange = true;
}
var item = map.Items.FirstOrDefault(x => string.Equals(x.QueryFrom, fieldName, StringComparison.InvariantCultureIgnoreCase));
if (item == null)
continue;
indexQuery.SortedFields[index] = new SortedField(hasRange ? item.To + "_Range" : item.To);
indexQuery.SortedFields[index].Descending = sortedField.Descending;
}
return indexQuery;
}
private static void UpdateFieldsInArray(DynamicQueryMapping map, string[] fields)
{
if (fields == null)
return;
for (var i = 0; i < fields.Length; i++)
{
var item = map.Items.FirstOrDefault(x => x.From == fields[i]);
if (item != null)
fields[i] = item.To;
}
}
public static DynamicQueryMapping Create(DocumentDatabase database, IndexQuery query, string entityName)
{
var fields = SimpleQueryParser.GetFieldsForDynamicQuery(query);
if (query.SortedFields != null)
{
foreach (var sortedField in query.SortedFields)
{
var field = sortedField.Field;
if (field.StartsWith(Constants.RandomFieldName))
{
continue;
}
if (field.StartsWith(Constants.CustomSortFieldName))
{
continue;
}
if (field == Constants.TemporaryScoreValue)
{
continue;
}
if (field.EndsWith("_Range"))
{
field = field.Substring(0, field.Length - "_Range".Length);
}
fields.Add(Tuple.Create(SimpleQueryParser.TranslateField(field), field));
}
}
var dynamicQueryMapping = new DynamicQueryMapping
{
ForEntityName = entityName,
HighlightedFields = query.HighlightedFields.EmptyIfNull().Select(x => x.Field).ToArray(),
SortDescriptors = GetSortInfo(fieldName =>
{
if (fields.Any(x => x.Item2 == fieldName || x.Item2 == (fieldName + "_Range")) == false)
{
fields.Add(Tuple.Create(fieldName, fieldName));
}
}, query)
};
dynamicQueryMapping.SetupFieldsToIndex(query, fields);
dynamicQueryMapping.SetupSortDescriptors(dynamicQueryMapping.SortDescriptors);
dynamicQueryMapping.FindIndexName(database, dynamicQueryMapping, query);
return(dynamicQueryMapping);
}
private Tuple<string, bool> GetAppropriateIndexToQuery(string entityName, IndexQuery query, DynamicQueryMapping map)
{
var appropriateIndex = new DynamicQueryOptimizer(documentDatabase).SelectAppropriateIndex(entityName, query);
if (appropriateIndex != null)
{
if (appropriateIndex.StartsWith("Temp/"))// temporary index, we need to increase its usage
{
return TouchTemporaryIndex(appropriateIndex, "Auto/" + appropriateIndex.Substring(5),
() => documentDatabase.IndexDefinitionStorage.GetIndexDefinition(appropriateIndex));
}
return Tuple.Create(appropriateIndex, false);
}
return TouchTemporaryIndex(map.TemporaryIndexName, map.PermanentIndexName,
map.CreateIndexDefinition);
}
public void CreateDefinitionSupportsArrayProperties()
{
Data.DynamicQueryMapping mapping = new Data.DynamicQueryMapping()
{
Items = new Data.DynamicQueryMappingItem[]{
new Data.DynamicQueryMappingItem(){
From = "Tags,Name",
To = "docTagsName"
}
}
};
var definition = mapping.CreateIndexDefinition();
Assert.Equal("from doc in docs\r\nfrom docTagsItem in doc.Tags\r\nselect new { docTagsName = docTagsItem.Name }", definition.Map);
}
public void CreateDefinitionSupportsArrayProperties()
{
Data.DynamicQueryMapping mapping = new Data.DynamicQueryMapping()
{
Items = new Data.DynamicQueryMappingItem[]{
new Data.DynamicQueryMappingItem(){
From = "Tags,Name",
To = "docTagsName"
}
}
};
var definition = mapping.CreateIndexDefinition();
Assert.Equal("from doc in docs\r\nfrom docTagsItem in (IEnumerable<dynamic>)doc.Tags\r\nselect new { docTagsName = docTagsItem.Name }", definition.Map);
}
public void CreateDefinitionSupportsNestedProperties()
{
Data.DynamicQueryMapping mapping = new Data.DynamicQueryMapping()
{
Items = new Data.DynamicQueryMappingItem[]{
new Data.DynamicQueryMappingItem(){
From = "User.Name",
To = "UserName"
}
}
};
var definition = mapping.CreateIndexDefinition();
Assert.Equal("from doc in docs\r\nselect new { UserName = doc.User.Name }", definition.Map);
}
private string FindDynamicIndexName(DynamicQueryMapping map)
{
var targetName = map.ForEntityName ?? "AllDocs";
var combinedFields = String.Join("And",
map.Items
.OrderBy(x => x.To)
.Select(x => x.To));
var indexName = combinedFields;
if (map.SortDescriptors != null && map.SortDescriptors.Length > 0)
{
indexName = string.Format("{0}SortBy{1}", indexName,
String.Join("",
map.SortDescriptors
.Select(x => x.Field)
.OrderBy(x => x)));
}
// Hash the name if it's too long
if (indexName.Length > 230)
{
using (var sha256 = SHA256.Create())
{
var bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(indexName));
indexName = Encoding.UTF8.GetString(bytes);
}
}
var permanentIndexName = indexName.Length == 0
? string.Format("Auto/{0}", targetName)
: string.Format("Auto/{0}/By{1}", targetName, indexName);
var temporaryIndexName = indexName.Length == 0
? string.Format("Temp/{0}", targetName)
: string.Format("Temp/{0}/By{1}", targetName, indexName);
// If there is a permanent index, then use that without bothering anything else
var permanentIndex = documentDatabase.GetIndexDefinition(permanentIndexName);
if (permanentIndex != null) { return permanentIndexName; }
// Else head down the temporary route
return TouchTemporaryIndex(map, temporaryIndexName, permanentIndexName);
}
private QueryResultWithIncludes ExecuteActualQuery(IndexQuery query, DynamicQueryMapping map, Tuple<string, bool> touchTemporaryIndexResult, string realQuery)
{
// Perform the query until we have some results at least
QueryResultWithIncludes result;
var sp = Stopwatch.StartNew();
while (true)
{
result = documentDatabase.Query(map.IndexName,
new IndexQuery
{
Cutoff = query.Cutoff,
PageSize = query.PageSize,
Query = realQuery,
Start = query.Start,
FieldsToFetch = query.FieldsToFetch,
GroupBy = query.GroupBy,
AggregationOperation = query.AggregationOperation,
SortedFields = query.SortedFields,
DefaultField = query.DefaultField,
CutoffEtag = query.CutoffEtag,
DebugOptionGetIndexEntries = query.DebugOptionGetIndexEntries,
DefaultOperator = query.DefaultOperator,
SkipTransformResults = query.SkipTransformResults,
SkippedResults = query.SkippedResults,
HighlighterPreTags = query.HighlighterPreTags,
HighlighterPostTags = query.HighlighterPostTags,
HighlightedFields = query.HighlightedFields,
ResultsTransformer = query.ResultsTransformer,
QueryInputs = query.QueryInputs
});
if (!touchTemporaryIndexResult.Item2 ||
!result.IsStale ||
(result.Results.Count >= query.PageSize && query.PageSize > 0) ||
sp.Elapsed.TotalSeconds > 15)
{
return result;
}
Thread.Sleep(100);
}
}
private QueryResultWithIncludes ExecuteActualQuery(IndexQuery query, DynamicQueryMapping map, Tuple<string, bool> touchTemporaryIndexResult, string realQuery)
{
// Perform the query until we have some results at least
QueryResultWithIncludes result;
var sp = Stopwatch.StartNew();
while (true)
{
var indexQuery = CreateIndexQuery(query, map, realQuery);
result = documentDatabase.Query(map.IndexName, indexQuery);
if (!touchTemporaryIndexResult.Item2 ||
!result.IsStale ||
(result.Results.Count >= query.PageSize && query.PageSize > 0) ||
sp.Elapsed.TotalSeconds > 15)
{
return result;
}
Thread.Sleep(100);
}
}
public static DynamicQueryMapping Create(DocumentDatabase database, IndexQuery query, string entityName)
{
var fields = SimpleQueryParser.GetFieldsForDynamicQuery(query);
if (query.SortedFields != null)
{
foreach (var sortedField in query.SortedFields)
{
if (sortedField.Field.StartsWith(Constants.RandomFieldName))
{
continue;
}
if (sortedField.Field == Constants.TemporaryScoreValue)
{
continue;
}
fields.Add(Tuple.Create(sortedField.Field, sortedField.Field));
}
}
var dynamicQueryMapping = new DynamicQueryMapping
{
AggregationOperation = query.AggregationOperation.RemoveOptionals(),
DynamicAggregation = query.AggregationOperation.HasFlag(AggregationOperation.Dynamic),
ForEntityName = entityName,
HighlightedFields = query.HighlightedFields.EmptyIfNull().Select(x => x.Field).ToArray(),
SortDescriptors = GetSortInfo(fieldName =>
{
if (fields.Any(x => x.Item2 == fieldName || x.Item2 == (fieldName + "_Range")) == false)
{
fields.Add(Tuple.Create(fieldName, fieldName));
}
})
};
dynamicQueryMapping.SetupFieldsToIndex(query, fields);
dynamicQueryMapping.SetupSortDescriptors(dynamicQueryMapping.SortDescriptors);
dynamicQueryMapping.FindIndexName(database, dynamicQueryMapping, query);
return(dynamicQueryMapping);
}
private void FindIndexName(DocumentDatabase database, DynamicQueryMapping map, IndexQuery query)
{
var targetName = map.ForEntityName ?? "AllDocs";
var combinedFields = String.Join("And",
map.Items
.OrderBy(x => x.To)
.Select(x => x.To));
var indexName = combinedFields;
if (map.SortDescriptors != null && map.SortDescriptors.Length > 0)
{
indexName = string.Format("{0}SortBy{1}", indexName,
String.Join("",
map.SortDescriptors
.Select(x => x.Field)
.OrderBy(x => x)));
}
if (map.HighlightedFields != null && map.HighlightedFields.Length > 0)
{
indexName = string.Format("{0}Highlight{1}", indexName,
string.Join("", map.HighlightedFields.OrderBy(x => x)));
}
string groupBy = null;
if (database.Configuration.RunInUnreliableYetFastModeThatIsNotSuitableForProduction == false &&
database.Configuration.RunInMemory == false)
{
indexName = IndexingUtil.FixupIndexName(indexName, database.Configuration.DataDirectory);
}
var permanentIndexName = indexName.Length == 0
? string.Format("Auto/{0}{1}", targetName, groupBy)
: string.Format("Auto/{0}/By{1}{2}", targetName, indexName, groupBy);
map.IndexName = permanentIndexName;
}
public static DynamicQueryMapping Create(DocumentDatabase database, IndexQuery query, string entityName)
{
var fields = SimpleQueryParser.GetFieldsForDynamicQuery(query.Query);
if (query.SortedFields != null)
{
foreach (var sortedField in query.SortedFields)
{
fields.Add(Tuple.Create(sortedField.Field, sortedField.Field));
}
}
var dynamicQueryMapping = new DynamicQueryMapping
{
AggregationOperation = query.AggregationOperation & ~AggregationOperation.Dynamic,
DynamicAggregation = (query.AggregationOperation & AggregationOperation.Dynamic) == AggregationOperation.Dynamic,
ForEntityName = entityName,
SortDescriptors = GetSortInfo(fields)
};
dynamicQueryMapping.SetupFieldsToIndex(query, fields);
dynamicQueryMapping.FindIndexName(database, dynamicQueryMapping, query);
return(dynamicQueryMapping);
}
private void CreateIndex(DynamicQueryMapping map, string indexName)
{
if (documentDatabase.GetIndexDefinition(indexName) != null) // avoid race condition when creating the index
return;
var definition = map.CreateIndexDefinition();
documentDatabase.PutIndex(indexName, definition);
}
private static IndexQuery CreateIndexQuery(IndexQuery query, DynamicQueryMapping map, string realQuery)
{
var indexQuery = new IndexQuery
{
Cutoff = query.Cutoff,
PageSize = query.PageSize,
Query = realQuery,
Start = query.Start,
FieldsToFetch = query.FieldsToFetch,
GroupBy = query.GroupBy,
AggregationOperation = query.AggregationOperation,
SortedFields = query.SortedFields,
DefaultField = query.DefaultField,
CutoffEtag = query.CutoffEtag,
DebugOptionGetIndexEntries = query.DebugOptionGetIndexEntries,
DefaultOperator = query.DefaultOperator,
SkipTransformResults = query.SkipTransformResults,
SkippedResults = query.SkippedResults,
HighlighterPreTags = query.HighlighterPreTags,
HighlighterPostTags = query.HighlighterPostTags,
HighlightedFields = query.HighlightedFields,
ResultsTransformer = query.ResultsTransformer,
QueryInputs = query.QueryInputs
};
if (indexQuery.SortedFields == null)
return indexQuery;
for (int index = 0; index < indexQuery.SortedFields.Length; index++)
{
var sortedField = indexQuery.SortedFields[index];
var fieldName = sortedField.Field;
bool hasRange = false;
if (fieldName.EndsWith("_Range"))
{
fieldName = fieldName.Substring(0, fieldName.Length - "_Range".Length);
hasRange = true;
}
var item = map.Items.FirstOrDefault(x => string.Equals(x.QueryFrom, fieldName, StringComparison.InvariantCultureIgnoreCase));
if (item == null)
continue;
indexQuery.SortedFields[index] = new SortedField(hasRange ? item.To + "_Range" : item.To);
indexQuery.SortedFields[index].Descending = sortedField.Descending;
}
return indexQuery;
}
public void CreateDefinitionSupportsNestedProperties()
{
Data.DynamicQueryMapping mapping = new Data.DynamicQueryMapping()
{
Items = new Data.DynamicQueryMappingItem[]{
new Data.DynamicQueryMappingItem(){
From = "User.Name",
To = "UserName"
}
}
};
var definition = mapping.CreateIndexDefinition();
Assert.Equal("from doc in docs\r\nselect new { UserName = doc.User.Name }", definition.Map);
}
private Tuple<string, bool> GetAppropriateIndexToQuery(string entityName, IndexQuery query, DynamicQueryMapping map)
{
var appropriateIndex = new DynamicQueryOptimizer(documentDatabase).SelectAppropriateIndex(entityName, query);
if (appropriateIndex.MatchType == DynamicQueryMatchType.Complete)
{
map.IndexName = appropriateIndex.IndexName;
return Tuple.Create(appropriateIndex.IndexName, false);
}
else if (appropriateIndex.MatchType == DynamicQueryMatchType.Partial)
{
// At this point, we found an index that has some fields we need and
// isn't incompatible with anything else we're asking for
// We need to clone that other index
// We need to add all our requested indexes information to our cloned index
// We can then use our new index instead
var currentIndex = documentDatabase.IndexDefinitionStorage.GetIndexDefinition(appropriateIndex.IndexName);
map.AddExistingIndexDefinition(currentIndex, documentDatabase, query);
}
return CreateAutoIndex(map.IndexName, map.CreateIndexDefinition);
}
private void FindIndexName(DocumentDatabase database, DynamicQueryMapping map, IndexQuery query)
{
var targetName = map.ForEntityName ?? "AllDocs";
var combinedFields = String.Join("And",
map.Items
.OrderBy(x => x.To)
.Select(x => x.To));
var indexName = combinedFields;
if (map.SortDescriptors != null && map.SortDescriptors.Length > 0)
{
indexName = string.Format("{0}SortBy{1}", indexName,
String.Join("",
map.SortDescriptors
.Select(x => x.Field)
.OrderBy(x => x)));
}
if (map.HighlightedFields != null && map.HighlightedFields.Length > 0)
{
indexName = string.Format("{0}Highlight{1}", indexName,
string.Join("", map.HighlightedFields.OrderBy(x => x)));
}
string groupBy = null;
if (database.Configuration.RunInUnreliableYetFastModeThatIsNotSuitableForProduction == false &&
database.Configuration.RunInMemory == false)
{
indexName = IndexingUtil.FixupIndexName(indexName, database.Configuration.DataDirectory);
}
var permanentIndexName = indexName.Length == 0
? string.Format("Auto/{0}{1}", targetName, groupBy)
: string.Format("Auto/{0}/By{1}{2}", targetName, indexName, groupBy);
map.IndexName = permanentIndexName;
}
public static DynamicQueryMapping Create(DocumentDatabase database, IndexQuery query, string entityName)
{
var fields = SimpleQueryParser.GetFieldsForDynamicQuery(query);
if (query.SortedFields != null)
{
foreach (var sortedField in query.SortedFields)
{
var field = sortedField.Field;
if (field.StartsWith(Constants.RandomFieldName))
continue;
if (field == Constants.TemporaryScoreValue)
continue;
if (field.EndsWith("_Range"))
field = field.Substring(0, field.Length - "_Range".Length);
fields.Add(Tuple.Create(SimpleQueryParser.TranslateField(field), field));
}
}
var dynamicQueryMapping = new DynamicQueryMapping
{
ForEntityName = entityName,
HighlightedFields = query.HighlightedFields.EmptyIfNull().Select(x => x.Field).ToArray(),
SortDescriptors = GetSortInfo(fieldName =>
{
if (fields.Any(x => x.Item2 == fieldName || x.Item2 == (fieldName + "_Range")) == false)
fields.Add(Tuple.Create(fieldName, fieldName));
}, query)
};
dynamicQueryMapping.SetupFieldsToIndex(query, fields);
dynamicQueryMapping.SetupSortDescriptors(dynamicQueryMapping.SortDescriptors);
dynamicQueryMapping.FindIndexName(database, dynamicQueryMapping, query);
return dynamicQueryMapping;
}
private void FindIndexName(DocumentDatabase database, DynamicQueryMapping map, IndexQuery query)
{
var targetName = map.ForEntityName ?? "AllDocs";
var combinedFields = String.Join("And",
map.Items
.OrderBy(x => x.To)
.Select(x => x.To));
var indexName = combinedFields;
if (map.SortDescriptors != null && map.SortDescriptors.Length > 0)
{
indexName = string.Format("{0}SortBy{1}", indexName,
String.Join("",
map.SortDescriptors
.Select(x => x.Field)
.OrderBy(x => x)));
}
if (map.HighlightedFields != null && map.HighlightedFields.Length > 0)
{
indexName = string.Format("{0}Highlight{1}", indexName,
string.Join("", map.HighlightedFields.OrderBy(x => x)));
}
string groupBy = null;
if (AggregationOperation != AggregationOperation.None)
{
if (query.GroupBy != null && query.GroupBy.Length > 0)
{
groupBy += "/" + AggregationOperation + "By" + string.Join("And", query.GroupBy);
}
else
{
groupBy += "/" + AggregationOperation;
}
if (DynamicAggregation)
{
groupBy += "Dynamically";
}
}
if (database.Configuration.RunInUnreliableYetFastModeThatIsNotSuitableForProduction == false &&
database.Configuration.RunInMemory == false)
{
// Hash the name if it's too long (as a path)
if ((database.Configuration.DataDirectory.Length + indexName.Length) > 230)
{
using (var sha256 = SHA256.Create())
{
var bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(indexName));
indexName = Convert.ToBase64String(bytes);
}
}
}
var permanentIndexName = indexName.Length == 0
? string.Format("Auto/{0}{1}", targetName, groupBy)
: string.Format("Auto/{0}/By{1}{2}", targetName, indexName, groupBy);
var temporaryIndexName = indexName.Length == 0
? string.Format("Temp/{0}{1}", targetName, groupBy)
: string.Format("Temp/{0}/By{1}{2}", targetName, indexName, groupBy);
map.IndexName = permanentIndexName;
}
private void FindIndexName(DocumentDatabase database, DynamicQueryMapping map, IndexQuery query)
{
var targetName = map.ForEntityName ?? "AllDocs";
var combinedFields = String.Join("And",
map.Items
.OrderBy(x => x.To)
.Select(x => x.To));
var indexName = combinedFields;
if (map.SortDescriptors != null && map.SortDescriptors.Length > 0)
{
indexName = string.Format("{0}SortBy{1}", indexName,
String.Join("",
map.SortDescriptors
.Select(x => x.Field)
.OrderBy(x => x)));
}
if (map.HighlightedFields != null && map.HighlightedFields.Length > 0)
{
indexName = string.Format("{0}Highlight{1}", indexName,
string.Join("", map.HighlightedFields.OrderBy(x => x)));
}
string groupBy = null;
if (AggregationOperation != AggregationOperation.None)
{
if (query.GroupBy != null && query.GroupBy.Length > 0)
{
groupBy += "/" + AggregationOperation + "By" + string.Join("And", query.GroupBy);
}
else
{
groupBy += "/" + AggregationOperation;
}
if (DynamicAggregation)
groupBy += "Dynamically";
}
if (database.Configuration.RunInUnreliableYetFastModeThatIsNotSuitableForProduction == false &&
database.Configuration.RunInMemory == false)
{
// Hash the name if it's too long (as a path)
if ((database.Configuration.DataDirectory.Length + indexName.Length) > 230)
{
using (var sha256 = SHA256.Create())
{
var bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(indexName));
indexName = Convert.ToBase64String(bytes);
}
}
}
var permanentIndexName = indexName.Length == 0
? string.Format("Auto/{0}{1}", targetName, groupBy)
: string.Format("Auto/{0}/By{1}{2}", targetName, indexName, groupBy);
var temporaryIndexName = indexName.Length == 0
? string.Format("Temp/{0}{1}", targetName, groupBy)
: string.Format("Temp/{0}/By{1}{2}", targetName, indexName, groupBy);
// If there is a permanent index, then use that without bothering anything else
var permanentIndex = database.GetIndexDefinition(permanentIndexName);
map.PermanentIndexName = permanentIndexName;
map.TemporaryIndexName = temporaryIndexName;
map.IndexName = permanentIndex != null ? permanentIndexName : temporaryIndexName;
}
public static DynamicQueryMapping Create(DocumentDatabase database, IndexQuery query, string entityName)
{
var fields = SimpleQueryParser.GetFieldsForDynamicQuery(query);
if (query.SortedFields != null)
{
foreach (var sortedField in query.SortedFields)
{
if (sortedField.Field.StartsWith(Constants.RandomFieldName))
continue;
if (sortedField.Field == Constants.TemporaryScoreValue)
continue;
fields.Add(Tuple.Create(sortedField.Field, sortedField.Field));
}
}
var dynamicQueryMapping = new DynamicQueryMapping
{
AggregationOperation = query.AggregationOperation.RemoveOptionals(),
DynamicAggregation = query.AggregationOperation.HasFlag(AggregationOperation.Dynamic),
ForEntityName = entityName,
HighlightedFields = query.HighlightedFields.EmptyIfNull().Select(x=>x.Field).ToArray(),
SortDescriptors = GetSortInfo(fieldName =>
{
if (fields.Any(x => x.Item2 == fieldName || x.Item2 == (fieldName + "_Range")) == false)
fields.Add(Tuple.Create(fieldName, fieldName));
})
};
dynamicQueryMapping.SetupFieldsToIndex(query, fields);
dynamicQueryMapping.SetupSortDescriptors(dynamicQueryMapping.SortDescriptors);
dynamicQueryMapping.FindIndexName(database, dynamicQueryMapping, query);
return dynamicQueryMapping;
}
public static DynamicQueryMapping Create(DocumentDatabase database, IndexQuery query, string entityName)
{
var fields = SimpleQueryParser.GetFieldsForDynamicQuery(query.Query);
if(query.SortedFields != null)
{
foreach (var sortedField in query.SortedFields)
{
fields.Add(Tuple.Create(sortedField.Field, sortedField.Field));
}
}
var dynamicQueryMapping = new DynamicQueryMapping
{
AggregationOperation = query.AggregationOperation & ~AggregationOperation.Dynamic,
DynamicAggregation = (query.AggregationOperation & AggregationOperation.Dynamic) == AggregationOperation.Dynamic,
ForEntityName = entityName,
SortDescriptors = GetSortInfo(fields)
};
dynamicQueryMapping.SetupFieldsToIndex(query, fields);
dynamicQueryMapping.FindIndexName(database, dynamicQueryMapping, query);
return dynamicQueryMapping;
}
private string TouchTemporaryIndex(DynamicQueryMapping map, string temporaryIndexName, string permanentIndexName)
{
var indexInfo = temporaryIndexes.GetOrAdd(temporaryIndexName, s => new TemporaryIndexInfo
{
Created = DateTime.Now,
RunCount = 0,
Name = temporaryIndexName
});
indexInfo.LastRun = DateTime.Now;
indexInfo.RunCount++;
if (TemporaryIndexShouldBeMadePermanent(indexInfo))
{
documentDatabase.DeleteIndex(temporaryIndexName);
CreateIndex(map, permanentIndexName);
TemporaryIndexInfo ignored;
temporaryIndexes.TryRemove(temporaryIndexName, out ignored);
return permanentIndexName;
}
var temporaryIndex = documentDatabase.GetIndexDefinition(temporaryIndexName);
if (temporaryIndex != null)
return temporaryIndexName;
CreateIndex(map, temporaryIndexName);
return temporaryIndexName;
}
public static DynamicQueryMapping Create(DocumentDatabase database, IndexQuery query, string entityName)
{
var fields = SimpleQueryParser.GetFieldsForDynamicQuery(query.Query);
if(query.SortedFields != null)
{
foreach (var sortedField in query.SortedFields)
{
fields.Add(Tuple.Create(sortedField.Field, sortedField.Field));
}
}
var dynamicQueryMapping = new DynamicQueryMapping
{
AggregationOperation = query.AggregationOperation.RemoveOptionals(),
DynamicAggregation = query.AggregationOperation.HasFlag(AggregationOperation.Dynamic),
ForEntityName = entityName,
SortDescriptors = GetSortInfo(fieldName =>
{
if (fields.Any(x => x.Item2 == fieldName || x.Item2 == (fieldName + "_Range")) == false)
fields.Add(Tuple.Create(fieldName, fieldName));
})
};
dynamicQueryMapping.SetupFieldsToIndex(query, fields);
dynamicQueryMapping.FindIndexName(database, dynamicQueryMapping, query);
return dynamicQueryMapping;
}
private void FindIndexName(DocumentDatabase database, DynamicQueryMapping map, IndexQuery query)
{
var targetName = map.ForEntityName ?? "AllDocs";
var combinedFields = String.Join("And",
map.Items
.OrderBy(x => x.To)
.Select(x => x.To));
var indexName = combinedFields;
if (map.SortDescriptors != null && map.SortDescriptors.Length > 0)
{
indexName = string.Format("{0}SortBy{1}", indexName,
String.Join("",
map.SortDescriptors
.Select(x => x.Field)
.OrderBy(x => x)));
}
if (map.HighlightedFields != null && map.HighlightedFields.Length > 0)
{
indexName = string.Format("{0}Highlight{1}", indexName,
string.Join("", map.HighlightedFields.OrderBy(x => x)));
}
string groupBy = null;
if (database.Configuration.RunInUnreliableYetFastModeThatIsNotSuitableForProduction == false &&
database.Configuration.RunInMemory == false)
{
// Hash the name if it's too long (as a path)
if ((database.Configuration.DataDirectory.Length + indexName.Length) > 230)
{
using (var sha256 = SHA256.Create())
{
var bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(indexName));
indexName = Convert.ToBase64String(bytes);
}
}
}
var permanentIndexName = indexName.Length == 0
? string.Format("Auto/{0}{1}", targetName, groupBy)
: string.Format("Auto/{0}/By{1}{2}", targetName, indexName, groupBy);
var temporaryIndexName = indexName.Length == 0
? string.Format("Temp/{0}{1}", targetName, groupBy)
: string.Format("Temp/{0}/By{1}{2}", targetName, indexName, groupBy);
map.IndexName = permanentIndexName;
}
