public void CanRemoveItemFromCacheWithDelegate() { var myObject1 = new TestCacheObject("test-1"); var myObject2 = new TestCacheObject("bob"); var myObject3 = new TestCacheObject("frank"); CacheProvider.AddOrChangeValue(CacheKey.Create <string>("my-1"), myObject1); CacheProvider.AddOrChangeValue(CacheKey.Create <StrongClassKey>(x => x.MyName = "bob"), myObject2); CacheProvider.AddOrChangeValue(CacheKey.Create <StrongClassKey>(x => x.MyName = "frank"), myObject3); var resultFilterClause = new ResultFilterClause(typeof(string), ResultFilterType.Any, 0); var fromClause = new FromClause(HiveId.Empty.ToString(), HierarchyScope.AncestorsOrSelf, FixedStatusTypes.Published); var fieldPredicateExpression = new FieldPredicateExpression("title", ValuePredicateType.Equal, "blah"); //var key = new HiveQueryCacheKey(new QueryDescription(resultFilterClause, fromClause, fieldPredicateExpression, Enumerable.Empty<SortClause>())); var key = CacheKey.Create(new HiveQueryCacheKey(new QueryDescription(resultFilterClause, fromClause, fieldPredicateExpression, Enumerable.Empty <SortClause>()))); CacheProvider.AddOrChangeValue(key, myObject3); Assert.NotNull(CacheProvider.GetValue(CacheKey.Create <string>("my-1"))); Assert.NotNull(CacheProvider.GetValue(CacheKey.Create <StrongClassKey>(x => x.MyName = "bob"))); Assert.NotNull(CacheProvider.GetValue(CacheKey.Create <string>("my-1"))); Assert.NotNull(CacheProvider.GetValue(key)); CacheProvider.RemoveWhereKeyMatches <string>(x => x == "my-1"); CacheProvider.RemoveWhereKeyMatches <StrongClassKey>(x => x.MyName == "bob"); CacheProvider.RemoveWhereKeyMatches <HiveQueryCacheKey>(x => x.From.HierarchyScope == HierarchyScope.AncestorsOrSelf); Assert.Null(CacheProvider.Get(CacheKey.Create <string>("my-1"))); Assert.Null(CacheProvider.GetValue(CacheKey.Create <string>("my-1"))); Assert.Null(CacheProvider.Get(CacheKey.Create <StrongClassKey>(x => x.MyName = "bob"))); Assert.NotNull(CacheProvider.Get(CacheKey.Create <StrongClassKey>(x => x.MyName = "frank"))); }
private static object GetIdValue(FieldPredicateExpression node) { var idValue = node.ValueExpression.Type.IsAssignableFrom(typeof(HiveId)) ? ((HiveId)node.ValueExpression.Value).Value.Value : node.ValueExpression.Value; return(idValue); }
private static Guid GetIdValue(FieldPredicateExpression node) { var idValue = Guid.Empty; if (node.ValueExpression.Type.IsAssignableFrom(typeof(HiveId))) { idValue = (Guid)((HiveId)node.ValueExpression.Value).Value; } else { Guid.TryParse(node.ValueExpression.Value.ToString(), out idValue); } return(idValue); }
public void CanRemoveItemFromCacheWithDelegate() { var myObject1 = new TestCacheObject("test-1"); var myObject2 = new TestCacheObject("bob"); var myObject3 = new TestCacheObject("frank"); CacheProvider.AddOrChangeValue(CacheKey.Create <string>("my-1"), myObject1); CacheProvider.AddOrChangeValue(CacheKey.Create <StrongClassKey>(x => x.MyName = "bob"), myObject2); CacheProvider.AddOrChangeValue(CacheKey.Create <StrongClassKey>(x => x.MyName = "frank"), myObject3); if (CacheIsAsync) { Thread.Sleep(500); } var resultFilterClause = new ResultFilterClause(typeof(string), ResultFilterType.Any, 0); var scopeStartId = new HiveId(Guid.NewGuid()); var fromClause = new FromClause(scopeStartId.AsEnumerableOfOne(), HierarchyScope.AncestorsOrSelf, FixedStatusTypes.Published); var fieldPredicateExpression = new FieldPredicateExpression("title", ValuePredicateType.Equal, "blah"); //var key = new HiveQueryCacheKey(new QueryDescription(resultFilterClause, fromClause, fieldPredicateExpression, Enumerable.Empty<SortClause>())); var key = CacheKey.Create(new HiveQueryCacheKey(new QueryDescription(resultFilterClause, fromClause, fieldPredicateExpression, Enumerable.Empty <SortClause>()))); CacheProvider.AddOrChangeValue(key, myObject3); if (CacheIsAsync) { Thread.Sleep(500); } Assert.NotNull(CacheProvider.GetValue <TestCacheObject>(CacheKey.Create <string>("my-1"))); Assert.NotNull(CacheProvider.GetValue <TestCacheObject>(CacheKey.Create <StrongClassKey>(x => x.MyName = "bob"))); Assert.NotNull(CacheProvider.GetValue <TestCacheObject>(CacheKey.Create <string>("my-1"))); Assert.NotNull(CacheProvider.GetValue <TestCacheObject>(key)); CacheProvider.RemoveWhereKeyMatches <string>(x => x == "my-1"); CacheProvider.RemoveWhereKeyMatches <StrongClassKey>(x => x.MyName == "bob"); CacheProvider.RemoveWhereKeyMatches <HiveQueryCacheKey>(x => x.From.HierarchyScope == HierarchyScope.AncestorsOrSelf); // No check for async as removals should be instant Assert.Null(CacheProvider.Get <TestCacheObject>(CacheKey.Create <string>("my-1"))); Assert.Null(CacheProvider.GetValue <TestCacheObject>(CacheKey.Create <string>("my-1"))); Assert.Null(CacheProvider.Get <TestCacheObject>(CacheKey.Create <StrongClassKey>(x => x.MyName = "bob"))); Assert.NotNull(CacheProvider.Get <TestCacheObject>(CacheKey.Create <StrongClassKey>(x => x.MyName = "frank"))); }
public override Expression <Func <XElement, bool> > VisitFieldPredicate(FieldPredicateExpression node) { var fieldName = node.SelectorExpression.FieldName; var fieldValue = node.ValueExpression.Value.ToString(); // Normalise incoming field names switch (fieldName.ToLowerInvariant()) { case "id": fieldName = "id"; var value = string.Empty; if (node.ValueExpression.Type.IsAssignableFrom(typeof(HiveId))) { value = ((HiveId)node.ValueExpression.Value).ToString(HiveIdFormatStyle.AutoSingleValue); } else { value = node.ValueExpression.Value.ToString(); } switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: return(x => x.Attributes(fieldName).Any() && string.Equals((string)x.Attribute(fieldName), value, StringComparison.InvariantCultureIgnoreCase)); case ValuePredicateType.NotEqual: return(x => x.Attributes(fieldName).Any() && !string.Equals((string)x.Attribute(fieldName), value, StringComparison.InvariantCultureIgnoreCase)); default: throw new InvalidOperationException("Cannot query an item by id by any other method than Equals or NotEquals"); } } switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: return(x => x.Attributes(fieldName).Any() && string.Equals((string)x.Attribute(fieldName), fieldValue, StringComparison.InvariantCultureIgnoreCase)); case ValuePredicateType.EndsWith: return(x => x.Attributes(fieldName).Any() && ((string)x.Attribute(fieldName)).EndsWith(fieldValue, StringComparison.InvariantCultureIgnoreCase)); } // Only get here if the query has something we don't support return(x => false); }
public void HiveQueryCacheKeyToFromJson() { var guid = Guid.NewGuid(); var guid2 = Guid.NewGuid(); var guid3 = Guid.NewGuid(); var resultFilterClause = new ResultFilterClause(typeof(string), ResultFilterType.Any, 0); var hiveId = new HiveId(guid); var expected = new HiveId(guid2); var fullHiveId = new HiveId(new Uri("content://blah/"), "nhibernate", new HiveIdValue(guid3)); var scopeStartId = new HiveId(Guid.NewGuid()); var fromClause = new FromClause(scopeStartId.AsEnumerableOfOne(), HierarchyScope.AncestorsOrSelf, FixedStatusTypes.Published, "default-type", new[] { hiveId, expected, fullHiveId }); var fieldPredicateExpression = new FieldPredicateExpression("title", ValuePredicateType.Equal, "blah"); var fieldPredicateExpression2 = new FieldPredicateExpression("title", ValuePredicateType.Equal, "blah"); var binary = Expression.MakeBinary(ExpressionType.ExclusiveOr, fieldPredicateExpression, fieldPredicateExpression2); var aSortClause = new SortClause(new FieldSelectorExpression("tag"), SortDirection.Descending, 2); //var key = new HiveQueryCacheKey(new QueryDescription(resultFilterClause, fromClause, fieldPredicateExpression, Enumerable.Empty<SortClause>())); var key = CacheKey.Create(new HiveQueryCacheKey(new QueryDescription(resultFilterClause, fromClause, fieldPredicateExpression, aSortClause.AsEnumerableOfOne()))); var keyJson = key.ToJson(); var keyBack = (CacheKey <HiveQueryCacheKey>)keyJson; // var keyJsonTwice = keyBack.ToJson(); Assert.That(keyBack, Is.Not.Null); //Assert.That(keyJson, Is.EqualTo(keyJsonTwice)); //NOTE: Criteria does not deserialize at the moment, but caching implementation should find matching keys OK still if it maintains an inner collection of original key objects if (key.Original.Criteria != null) Assert.That(keyBack.Original.Criteria, Is.Not.Null); Assert.True(keyBack.Original.ResultFilters.Any()); Assert.That(keyBack.Original.ResultFilters.First().ResultType, Is.EqualTo(typeof(string))); Assert.That(keyBack.Original.SortClauses.Count(), Is.EqualTo(key.Original.SortClauses.Count())); Assert.That(keyBack.Original.SortClauses.FirstOrDefault().Direction, Is.EqualTo(SortDirection.Descending)); Assert.That(keyBack.Original.SortClauses.FirstOrDefault().Priority, Is.EqualTo(2)); Assert.That(keyBack.Original.From.HierarchyScope, Is.EqualTo(key.Original.From.HierarchyScope)); Assert.That(keyBack.Original.From.RequiredEntityIds.Count(), Is.EqualTo(3)); Assert.That(keyBack.Original.From.RequiredEntityIds.FirstOrDefault(), Is.EqualTo(hiveId)); Assert.That(keyBack.Original.From.RequiredEntityIds.FirstOrDefault().Value.Type, Is.EqualTo(HiveIdValueTypes.Guid)); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(1), Is.EqualTo(expected)); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(1).Value.Type, Is.EqualTo(HiveIdValueTypes.Guid)); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2), Is.EqualTo(fullHiveId)); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2).Value.Type, Is.EqualTo(HiveIdValueTypes.Guid)); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2).ProviderId, Is.EqualTo("nhibernate")); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2).ProviderGroupRoot.ToString(), Is.EqualTo(fullHiveId.ProviderGroupRoot.ToString())); }
/// <summary> /// Negates a field predicate, i.e. reverses its <see cref="ValuePredicateType"/> for example Equals will be switched to NotEquals. /// </summary> /// <param name="fieldPredicateExpression">The field predicate expression.</param> /// <returns></returns> /// <remarks></remarks> public static FieldPredicateExpression NegateFieldPredicate(FieldPredicateExpression fieldPredicateExpression) { Func<ValuePredicateType> reversed = () => { switch (fieldPredicateExpression.ValueExpression.ClauseType) { case ValuePredicateType.Equal: return ValuePredicateType.NotEqual; case ValuePredicateType.GreaterThan: return ValuePredicateType.LessThan; case ValuePredicateType.GreaterThanOrEqual: return ValuePredicateType.LessThanOrEqual; case ValuePredicateType.NotEqual: return ValuePredicateType.Equal; } return fieldPredicateExpression.ValueExpression.ClauseType; }; return new FieldPredicateExpression(fieldPredicateExpression.SelectorExpression, new FieldValueExpression(reversed.Invoke(), fieldPredicateExpression.ValueExpression.Value)); }
public override Expression VisitFieldPredicate(FieldPredicateExpression node) { if (node.SelectorExpression == null) { _expressionsFound.Append("(SelectorExpression == null)"); return(node); } _expressionsFound.AppendFormat("\nField: {0} {1} {2}", node.SelectorExpression.FieldName, node.ValueExpression.ClauseType.ToString(), node.ValueExpression.Value); if (node.SelectorExpression.FieldName == _fieldName && node.ValueExpression.Value.Equals(_fieldValue) && node.ValueExpression.ClauseType == _valuePredicateType) { if ((_subFieldName != null && node.SelectorExpression.ValueKey == _subFieldName) || _subFieldName == null) { FoundMatch = true; } } return(node); }
public void HiveQueryCacheKeyToFromJson() { var guid = Guid.NewGuid(); var guid2 = Guid.NewGuid(); var guid3 = Guid.NewGuid(); var resultFilterClause = new ResultFilterClause(typeof(string), ResultFilterType.Any, 0); var hiveId = new HiveId(guid); var expected = new HiveId(guid2); var fullHiveId = new HiveId(new Uri("content://blah/"), "nhibernate", new HiveIdValue(guid3)); var scopeStartId = new HiveId(Guid.NewGuid()); var fromClause = new FromClause(scopeStartId.AsEnumerableOfOne(), HierarchyScope.AncestorsOrSelf, FixedStatusTypes.Published, "default-type", new[] { hiveId, expected, fullHiveId }); var fieldPredicateExpression = new FieldPredicateExpression("title", ValuePredicateType.Equal, "blah"); var fieldPredicateExpression2 = new FieldPredicateExpression("title", ValuePredicateType.Equal, "blah"); var binary = Expression.MakeBinary(ExpressionType.ExclusiveOr, fieldPredicateExpression, fieldPredicateExpression2); var aSortClause = new SortClause(new FieldSelectorExpression("tag"), SortDirection.Descending, 2); //var key = new HiveQueryCacheKey(new QueryDescription(resultFilterClause, fromClause, fieldPredicateExpression, Enumerable.Empty<SortClause>())); var key = CacheKey.Create(new HiveQueryCacheKey(new QueryDescription(resultFilterClause, fromClause, fieldPredicateExpression, aSortClause.AsEnumerableOfOne()))); var keyJson = key.ToJson(); var keyBack = (CacheKey<HiveQueryCacheKey>)keyJson; // var keyJsonTwice = keyBack.ToJson(); Assert.That(keyBack, Is.Not.Null); //Assert.That(keyJson, Is.EqualTo(keyJsonTwice)); //NOTE: Criteria does not deserialize at the moment, but caching implementation should find matching keys OK still if it maintains an inner collection of original key objects if (key.Original.Criteria != null) Assert.That(keyBack.Original.Criteria, Is.Not.Null); Assert.True(keyBack.Original.ResultFilters.Any()); Assert.That(keyBack.Original.ResultFilters.First().ResultType, Is.EqualTo(typeof(string))); Assert.That(keyBack.Original.SortClauses.Count(), Is.EqualTo(key.Original.SortClauses.Count())); Assert.That(keyBack.Original.SortClauses.FirstOrDefault().Direction, Is.EqualTo(SortDirection.Descending)); Assert.That(keyBack.Original.SortClauses.FirstOrDefault().Priority, Is.EqualTo(2)); Assert.That(keyBack.Original.From.HierarchyScope, Is.EqualTo(key.Original.From.HierarchyScope)); Assert.That(keyBack.Original.From.RequiredEntityIds.Count(), Is.EqualTo(3)); Assert.That(keyBack.Original.From.RequiredEntityIds.FirstOrDefault(), Is.EqualTo(hiveId)); Assert.That(keyBack.Original.From.RequiredEntityIds.FirstOrDefault().Value.Type, Is.EqualTo(HiveIdValueTypes.Guid)); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(1), Is.EqualTo(expected)); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(1).Value.Type, Is.EqualTo(HiveIdValueTypes.Guid)); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2), Is.EqualTo(fullHiveId)); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2).Value.Type, Is.EqualTo(HiveIdValueTypes.Guid)); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2).ProviderId, Is.EqualTo("nhibernate")); Assert.That(keyBack.Original.From.RequiredEntityIds.ElementAt(2).ProviderGroupRoot.ToString(), Is.EqualTo(fullHiveId.ProviderGroupRoot.ToString())); }
public override Expression VisitFieldPredicate(FieldPredicateExpression node) { _expressionsFound.AppendFormat("\n{0}", node); foreach (var fieldPredicateExpression in _tester.Fields) { if (node.SelectorExpression.FieldName == fieldPredicateExpression.SelectorExpression.FieldName && node.ValueExpression.Value.Equals(fieldPredicateExpression.ValueExpression.Value) && node.ValueExpression.ClauseType == fieldPredicateExpression.ValueExpression.ClauseType) { if ((fieldPredicateExpression.SelectorExpression.ValueKey != null && node.SelectorExpression.ValueKey == fieldPredicateExpression.SelectorExpression.ValueKey) || fieldPredicateExpression.SelectorExpression.ValueKey == null) { FoundMatch = true; break; } } } return(node); }
/// <summary> /// Negates a field predicate, i.e. reverses its <see cref="ValuePredicateType"/> for example Equals will be switched to NotEquals. /// </summary> /// <param name="fieldPredicateExpression">The field predicate expression.</param> /// <returns></returns> /// <remarks></remarks> public static FieldPredicateExpression NegateFieldPredicate(FieldPredicateExpression fieldPredicateExpression) { Func <ValuePredicateType> reversed = () => { switch (fieldPredicateExpression.ValueExpression.ClauseType) { case ValuePredicateType.Equal: return(ValuePredicateType.NotEqual); case ValuePredicateType.GreaterThan: return(ValuePredicateType.LessThan); case ValuePredicateType.GreaterThanOrEqual: return(ValuePredicateType.LessThanOrEqual); case ValuePredicateType.NotEqual: return(ValuePredicateType.Equal); } return(fieldPredicateExpression.ValueExpression.ClauseType); }; return(new FieldPredicateExpression(fieldPredicateExpression.SelectorExpression, new FieldValueExpression(reversed.Invoke(), fieldPredicateExpression.ValueExpression.Value))); }
public override MembershipProviderQuery VisitFieldPredicate(FieldPredicateExpression node) { var fieldName = node.SelectorExpression.FieldName; var valueKey = node.SelectorExpression.ValueKey; var fieldValue = node.ValueExpression.Value.ToString(); switch (fieldName.ToLowerInvariant()) { case "id": var idValue = GetIdValue(node); switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: return(new MembershipProviderQuery(MembershipQueryType.ById, idValue)); case ValuePredicateType.NotEqual: Func <IEnumerable <MembershipUser>, IEnumerable <MembershipUser> > filter = x => x.Where(m => m.ProviderUserKey != idValue); return(new MembershipProviderQuery(MembershipQueryType.Custom, filter)); default: throw new InvalidOperationException( "Cannot query an item by id by any other operator than == or !="); } } if (!valueKey.IsNullOrWhiteSpace()) { throw new NotImplementedException(); } //now, select the field value.... switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: if (fieldName.InvariantEquals(MemberSchema.EmailAlias)) { return(new MembershipProviderQuery(MembershipQueryType.ByEmail, fieldValue)); } if (fieldName.InvariantEquals(MemberSchema.UsernameAlias)) { return(new MembershipProviderQuery(MembershipQueryType.ByUsername, fieldValue)); } throw new NotSupportedException("The Membership wrapper Hive provider does not support querying fields other than Email and Username"); case ValuePredicateType.NotEqual: if (fieldName.InvariantEquals(MemberSchema.EmailAlias)) { Func <IEnumerable <MembershipUser>, IEnumerable <MembershipUser> > filter = x => x.Where(m => m.Email != fieldValue); return(new MembershipProviderQuery(MembershipQueryType.Custom, filter)); } if (fieldName.InvariantEquals(MemberSchema.UsernameAlias)) { Func <IEnumerable <MembershipUser>, IEnumerable <MembershipUser> > filter = x => x.Where(m => m.UserName != fieldValue); return(new MembershipProviderQuery(MembershipQueryType.Custom, filter)); } throw new NotSupportedException("The Membership wrapper Hive provider does not support querying fields other than Email and Username"); case ValuePredicateType.MatchesWildcard: case ValuePredicateType.Contains: if (fieldName.InvariantEquals(MemberSchema.EmailAlias)) { return(new MembershipProviderQuery(MembershipQueryType.ByEmail, fieldValue, ValuePredicateType.Contains)); } if (fieldName.InvariantEquals(MemberSchema.UsernameAlias)) { return(new MembershipProviderQuery(MembershipQueryType.ByUsername, fieldValue, ValuePredicateType.Contains)); } throw new NotSupportedException("The Membership wrapper Hive provider does not support querying fields other than Email and Username"); case ValuePredicateType.StartsWith: if (fieldName.InvariantEquals(MemberSchema.EmailAlias)) { return(new MembershipProviderQuery(MembershipQueryType.ByEmail, fieldValue, ValuePredicateType.StartsWith)); } if (fieldName.InvariantEquals(MemberSchema.UsernameAlias)) { return(new MembershipProviderQuery(MembershipQueryType.ByUsername, fieldValue, ValuePredicateType.StartsWith)); } throw new NotSupportedException("The Membership wrapper Hive provider does not support querying fields other than Email and Username"); case ValuePredicateType.EndsWith: if (fieldName.InvariantEquals(MemberSchema.EmailAlias)) { return(new MembershipProviderQuery(MembershipQueryType.ByEmail, fieldValue, ValuePredicateType.EndsWith)); } if (fieldName.InvariantEquals(MemberSchema.UsernameAlias)) { return(new MembershipProviderQuery(MembershipQueryType.ByUsername, fieldValue, ValuePredicateType.EndsWith)); } throw new NotSupportedException("The Membership wrapper Hive provider does not support querying fields other than Email and Username"); default: throw new InvalidOperationException( "This linq provider doesn't support a ClauseType of {0} for field {1}".InvariantFormat( node.ValueExpression.ClauseType.ToString(), fieldName)); } }
public override QueryOver <NodeVersion> VisitFieldPredicate(FieldPredicateExpression node) { var fieldName = node.SelectorExpression.FieldName; var valueKey = node.SelectorExpression.ValueKey; var fieldValue = node.ValueExpression.Value; switch (fieldName.ToLowerInvariant()) { case "id": Guid idValue = GetIdValue(node); switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: return(QueryOver.Of <NodeVersion>().Where(x => x.Node.Id == idValue).Select(x => x.Id)); case ValuePredicateType.NotEqual: return(QueryOver.Of <NodeVersion>().Where(x => x.Node.Id != idValue).Select(x => x.Id));; default: throw new InvalidOperationException( "Cannot query an item by id by any other operator than == or !="); } } NodeVersion aliasNodeVersion = null; Attribute aliasAttribute = null; AttributeDefinition aliasAttributeDefinition = null; AttributeStringValue aliasStringValue = null; AttributeLongStringValue aliasLongStringValue = null; NodeRelation aliasNodeRelation = null; AttributeDateValue aliasDateValue = null; //TODO: This is going to need to lookup more than string values var queryString = QueryOver.Of <NodeVersion>(() => aliasNodeVersion) .JoinQueryOver <Attribute>(() => aliasNodeVersion.Attributes, () => aliasAttribute) .JoinQueryOver <AttributeDefinition>(() => aliasAttribute.AttributeDefinition, () => aliasAttributeDefinition) .Left.JoinQueryOver <AttributeStringValue>(() => aliasAttribute.AttributeStringValues, () => aliasStringValue) .Left.JoinQueryOver <AttributeLongStringValue>(() => aliasAttribute.AttributeLongStringValues, () => aliasLongStringValue) .Left.JoinQueryOver(() => aliasAttribute.AttributeDateValues, () => aliasDateValue) //select the field name... .Where(x => aliasAttributeDefinition.Alias == fieldName); if (!valueKey.IsNullOrWhiteSpace()) { //if the value key is specified, then add that to the query queryString = queryString.And(() => aliasStringValue.ValueKey == valueKey || aliasLongStringValue.ValueKey == valueKey).Select(x => x.Id); } //now, select the field value.... switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: var sqlCeCompatibleQuery = Restrictions.Or( Restrictions.Eq( Projections.Property <AttributeStringValue>(x => aliasStringValue.Value), fieldValue), Restrictions.Like( Projections.Property <AttributeLongStringValue>(x => aliasLongStringValue.Value), fieldValue as string, MatchMode.Exact)); return(queryString.And(sqlCeCompatibleQuery).Select(x => x.Id)); case ValuePredicateType.NotEqual: return(queryString.And(x => aliasStringValue.Value != fieldValue).Select(x => x.Id)); case ValuePredicateType.MatchesWildcard: case ValuePredicateType.Contains: return(queryString.And(Restrictions.Like(Projections.Property <AttributeStringValue>(x => aliasStringValue.Value), fieldValue as string, MatchMode.Anywhere)).Select(x => x.Id)); case ValuePredicateType.StartsWith: return(queryString.And(Restrictions.Like(Projections.Property <AttributeStringValue>(x => aliasStringValue.Value), fieldValue as string, MatchMode.Start)).Select(x => x.Id)); case ValuePredicateType.EndsWith: return(queryString.And(Restrictions.Like(Projections.Property <AttributeStringValue>(x => aliasStringValue.Value), fieldValue as string, MatchMode.End)).Select(x => x.Id)); case ValuePredicateType.LessThanOrEqual: return (queryString.And( Restrictions.Le(Projections.Property <AttributeDateValue>(x => aliasDateValue.Value), (DateTimeOffset)fieldValue))); case ValuePredicateType.GreaterThanOrEqual: return (queryString.And( Restrictions.Ge(Projections.Property <AttributeDateValue>(x => aliasDateValue.Value), (DateTimeOffset)fieldValue))); default: throw new InvalidOperationException( "This linq provider doesn't support a ClauseType of {0} for field {1}".InvariantFormat( node.ValueExpression.ClauseType.ToString(), fieldName)); } }
public abstract T VisitFieldPredicate(FieldPredicateExpression node);
public override QueryOver <NodeVersion> VisitFieldPredicate(FieldPredicateExpression node) { var fieldName = node.SelectorExpression.FieldName; var valueKey = node.SelectorExpression.ValueKey; var fieldValue = node.ValueExpression.Value; var fieldValueType = fieldValue != null?fieldValue.GetType() : typeof(string); switch (fieldName.ToLowerInvariant()) { case "id": Guid idValue = GetIdValue(node); switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: return(QueryOver.Of <NodeVersion>().Where(x => x.Node.Id == idValue).Select(x => x.Id)); case ValuePredicateType.NotEqual: return(QueryOver.Of <NodeVersion>().Where(x => x.Node.Id != idValue).Select(x => x.Id));; default: throw new InvalidOperationException( "Cannot query an item by id by any other operator than == or !="); } } // First look up the types of the main field AttributeDefinition defAlias = null; AttributeType typeAlias = null; var attributeType = _activeSession.QueryOver <AttributeDefinition>(() => defAlias) .JoinAlias(() => defAlias.AttributeType, () => typeAlias) .Where(() => defAlias.Alias == fieldName) .Select(x => typeAlias.PersistenceTypeProvider) .List <string>(); var typesAlreadyEstablished = new List <string>(); var typesToQuery = new List <DataSerializationTypes>(); foreach (var type in attributeType) { var typeName = type; if (typesAlreadyEstablished.Contains(typeName)) { continue; } try { typesAlreadyEstablished.Add(typeName); var persisterType = Type.GetType(typeName, false); if (persisterType != null) { var persisterInstance = Activator.CreateInstance(persisterType) as IAttributeSerializationDefinition; if (persisterInstance != null) { typesToQuery.Add(persisterInstance.DataSerializationType); } } } catch (Exception) { throw; } } // U5-789 // Workaround pending a better check of what data is actually saved // An issue arose because previous data had been saved in long-string, // but the datatype changed to be just string, therefore only string was // being queried despite all the data residing still in long-string if (typesToQuery.Contains(DataSerializationTypes.String) && !typesToQuery.Contains(DataSerializationTypes.LongString)) { typesToQuery.Add(DataSerializationTypes.LongString); } NodeVersion aliasNodeVersion = null; Attribute aliasAttribute = null; AttributeDefinition aliasAttributeDefinition = null; AttributeStringValue aliasStringValue = null; AttributeLongStringValue aliasLongStringValue = null; AttributeIntegerValue aliasIntegerValue = null; AttributeDecimalValue aliasDecimalValue = null; NodeRelation aliasNodeRelation = null; AttributeDateValue aliasDateValue = null; QueryOver <NodeVersion, AttributeDefinition> queryExtender = QueryOver.Of <NodeVersion>(() => aliasNodeVersion) .JoinQueryOver <Attribute>(() => aliasNodeVersion.Attributes, () => aliasAttribute) .JoinQueryOver <AttributeDefinition>(() => aliasAttribute.AttributeDefinition, () => aliasAttributeDefinition); int numberOfMatchesEvaluated = 0; AbstractCriterion restrictionBuilder = null; foreach (var dataSerializationTypese in typesToQuery.Distinct()) { AbstractCriterion restriction = null; Expression <Func <object> > propertyExpression = null; Expression <Func <object> > subkeyExpression = null; List <ValuePredicateType> validClauseTypes = null; var useLikeMatchForStrings = false; switch (dataSerializationTypese) { case DataSerializationTypes.SmallInt: case DataSerializationTypes.LargeInt: case DataSerializationTypes.Boolean: queryExtender = queryExtender.Left.JoinAlias(() => aliasAttribute.AttributeIntegerValues, () => aliasIntegerValue); propertyExpression = () => aliasIntegerValue.Value; subkeyExpression = () => aliasIntegerValue.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual }; break; case DataSerializationTypes.Decimal: queryExtender = queryExtender.Left.JoinAlias(() => aliasAttribute.AttributeDecimalValues, () => aliasDecimalValue); propertyExpression = () => aliasDecimalValue.Value; subkeyExpression = () => aliasDecimalValue.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual }; break; case DataSerializationTypes.String: queryExtender = queryExtender.Left.JoinAlias(() => aliasAttribute.AttributeStringValues, () => aliasStringValue); propertyExpression = () => aliasStringValue.Value; subkeyExpression = () => aliasStringValue.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.NotEqual, ValuePredicateType.Contains, ValuePredicateType.StartsWith, ValuePredicateType.EndsWith, ValuePredicateType.MatchesWildcard }; break; case DataSerializationTypes.LongString: queryExtender = queryExtender.Left.JoinAlias(() => aliasAttribute.AttributeLongStringValues, () => aliasLongStringValue); propertyExpression = () => aliasLongStringValue.Value; subkeyExpression = () => aliasLongStringValue.ValueKey; useLikeMatchForStrings = true; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.NotEqual, ValuePredicateType.Contains, ValuePredicateType.StartsWith, ValuePredicateType.EndsWith, ValuePredicateType.MatchesWildcard }; break; case DataSerializationTypes.Date: queryExtender = queryExtender.Left.JoinAlias(() => aliasAttribute.AttributeDateValues, () => aliasDateValue); propertyExpression = () => aliasDateValue.Value; subkeyExpression = () => aliasDateValue.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual, ValuePredicateType.Empty }; break; } if (!validClauseTypes.Contains(node.ValueExpression.ClauseType)) { throw new InvalidOperationException("A field of type {0} cannot be queried with operator {1}".InvariantFormat(dataSerializationTypese.ToString(), node.ValueExpression.ClauseType.ToString())); } switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: restriction = GetRestrictionEq(fieldValue, useLikeMatchForStrings, propertyExpression, subkeyExpression, valueKey); break; case ValuePredicateType.NotEqual: restriction = !GetRestrictionEq(fieldValue, useLikeMatchForStrings, propertyExpression); break; case ValuePredicateType.LessThan: restriction = GetRestrictionLt(fieldValue, propertyExpression); break; case ValuePredicateType.LessThanOrEqual: restriction = GetRestrictionLtEq(fieldValue, propertyExpression); break; case ValuePredicateType.GreaterThan: restriction = GetRestrictionGt(fieldValue, propertyExpression); break; case ValuePredicateType.GreaterThanOrEqual: restriction = GetRestrictionGtEq(fieldValue, propertyExpression); break; case ValuePredicateType.Contains: restriction = GetRestrictionContains(fieldValue, propertyExpression); break; case ValuePredicateType.StartsWith: restriction = GetRestrictionStarts(fieldValue, propertyExpression); break; case ValuePredicateType.EndsWith: restriction = GetRestrictionEnds(fieldValue, propertyExpression); break; } if (restriction != null) { if (numberOfMatchesEvaluated == 0) { restrictionBuilder = restriction; numberOfMatchesEvaluated++; } else { restrictionBuilder = Restrictions.Or(restriction, restrictionBuilder); } } } if (restrictionBuilder != null) { queryExtender = queryExtender.Where(restrictionBuilder); } queryExtender = queryExtender .And(x => aliasAttributeDefinition.Alias == fieldName); return(queryExtender.Select(x => x.Id)); }
public void BooleanEquals() { var lookForPredicate = new FieldPredicateExpression("isTrue", ValuePredicateType.Equal, true); Run(GetQueryBooleanEquals("isTrue", true).WithField(lookForPredicate)); }
public override ICriterion VisitFieldPredicate(FieldPredicateExpression node) { var fieldName = node.SelectorExpression.FieldName; var valueKey = node.SelectorExpression.ValueKey; var fieldValue = node.ValueExpression.Value; var fieldValueType = fieldValue != null?fieldValue.GetType() : typeof(string); switch (fieldName.ToLowerInvariant()) { case "utccreated": var dateValue = (DateTimeOffset)fieldValue; if (dateValue == default(DateTimeOffset)) { break; } _requiresOuterNodeJoin = true; switch (node.ValueExpression.ClauseType) { case ValuePredicateType.LessThanOrEqual: return(Restrictions.Le(Projections.Property(() => outerNode.DateCreated), dateValue)); } break; case "id": Guid idValue = GetIdValue(node); switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: _discoveredRequiredNodeIds.Add(idValue); return(Restrictions.Eq(Projections.Property(() => version.Node.Id), idValue)); case ValuePredicateType.NotEqual: _negatingNodeIdsExist = true; return(!Restrictions.Eq(Projections.Property(() => version.Node.Id), idValue)); default: throw new InvalidOperationException( "Cannot query an item by id by any other operator than == or !="); } case "system-internal-selected-template": //TODO Pending property editors getting involved in query modification prior to being passed to hive provider, //manually check for queries against a template here if (valueKey == "TemplateId" && fieldValue != null) { var tryParseResult = HiveId.TryParse(fieldValue.ToString()); if (!tryParseResult.Success || tryParseResult.Result.ProviderGroupRoot == null || tryParseResult.Result.ProviderId == null || (tryParseResult.Result.ProviderGroupRoot.AbsoluteUri != "storage://" && tryParseResult.Result.ProviderId != "templates")) { var normalisedFieldValue = "/" + fieldValue.ToString().TrimStart("/").TrimEnd(".") + "."; // Need to convert the value into the serialized form that a HiveId would use var newValue = new HiveId("storage", "templates", new HiveIdValue(normalisedFieldValue)).ToString(HiveIdFormatStyle.UriSafe); fieldValue = newValue; } else { fieldValue = tryParseResult.Result.ToString(HiveIdFormatStyle.UriSafe); } } break; } // First look up the types of the main field AttributeDefinition defAlias = null; AttributeType typeAlias = null; var attributeType = _activeSession.NhSession.QueryOver <AttributeDefinition>(() => defAlias) .JoinAlias(() => defAlias.AttributeType, () => typeAlias) .Where(() => defAlias.Alias == fieldName) .Select(x => typeAlias.PersistenceTypeProvider) .List <string>(); foreach (var type in attributeType) { var typeName = type; if (_typesAlreadyEstablished.Contains(typeName)) { continue; } try { _typesAlreadyEstablished.Add(typeName); var persisterType = Type.GetType(typeName, false); if (persisterType != null) { var persisterInstance = Activator.CreateInstance(persisterType) as IAttributeSerializationDefinition; if (persisterInstance != null && !_typesToQuery.Contains(persisterInstance.DataSerializationType)) { _typesToQuery.Add(persisterInstance.DataSerializationType); } } } catch (Exception ex) { LogHelper.Error <NhCriteriaVisitor>("Error while trying to decide which value-tables to join & query", ex); throw; } } // U5-789 // Workaround pending a better check of what data is actually saved // An issue arose because previous data had been saved in long-string, // but the datatype changed to be just string, therefore only string was // being queried despite all the data residing still in long-string if (_typesToQuery.Contains(DataSerializationTypes.String) && !_typesToQuery.Contains(DataSerializationTypes.LongString)) { _typesToQuery.Add(DataSerializationTypes.LongString); } //NodeVersion aliasNodeVersion = null; //Attribute aliasAttribute = null; //AttributeDefinition aliasAttributeDefinition = null; //AttributeStringValue aliasStringValue = null; //AttributeLongStringValue aliasLongStringValue = null; //AttributeIntegerValue aliasIntegerValue = null; //AttributeDecimalValue aliasDecimalValue = null; //NodeRelation aliasNodeRelation = null; //AttributeDateValue aliasDateValue = null; //QueryOver<NodeVersion, AttributeDefinition> queryExtender = QueryOver.Of<NodeVersion>(() => aliasNodeVersion) // .JoinQueryOver<Attribute>(() => aliasNodeVersion.Attributes, () => aliasAttribute) // .JoinQueryOver<AttributeDefinition>(() => aliasAttribute.AttributeDefinition, () => aliasAttributeDefinition); int numberOfMatchesEvaluated = 0; AbstractCriterion restrictionBuilder = null; foreach (var dataSerializationTypese in _typesToQuery.Distinct()) { AbstractCriterion restriction = null; global::System.Linq.Expressions.Expression <Func <object> > propertyExpression = null; global::System.Linq.Expressions.Expression <Func <object> > subkeyExpression = null; List <ValuePredicateType> validClauseTypes = null; var useLikeMatchForStrings = false; switch (dataSerializationTypese) { case DataSerializationTypes.SmallInt: case DataSerializationTypes.LargeInt: case DataSerializationTypes.Boolean: propertyExpression = () => integerVal.Value; subkeyExpression = () => integerVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual }; break; case DataSerializationTypes.Decimal: propertyExpression = () => decimalVal.Value; subkeyExpression = () => decimalVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual }; break; case DataSerializationTypes.String: propertyExpression = () => stringVal.Value; subkeyExpression = () => stringVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.NotEqual, ValuePredicateType.Contains, ValuePredicateType.StartsWith, ValuePredicateType.EndsWith, ValuePredicateType.MatchesWildcard }; break; case DataSerializationTypes.LongString: propertyExpression = () => longStrVal.Value; subkeyExpression = () => longStrVal.ValueKey; useLikeMatchForStrings = true; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.NotEqual, ValuePredicateType.Contains, ValuePredicateType.StartsWith, ValuePredicateType.EndsWith, ValuePredicateType.MatchesWildcard }; break; case DataSerializationTypes.Date: propertyExpression = () => dateVal.Value; subkeyExpression = () => dateVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual, ValuePredicateType.Empty }; break; } if (!validClauseTypes.Contains(node.ValueExpression.ClauseType)) { throw new InvalidOperationException("A field of type {0} cannot be queried with operator {1}".InvariantFormat(dataSerializationTypese.ToString(), node.ValueExpression.ClauseType.ToString())); } switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: restriction = GetRestrictionEq(fieldValue, useLikeMatchForStrings, propertyExpression, subkeyExpression, valueKey); break; case ValuePredicateType.NotEqual: restriction = !GetRestrictionEq(fieldValue, useLikeMatchForStrings, propertyExpression); break; case ValuePredicateType.LessThan: restriction = GetRestrictionLt(fieldValue, propertyExpression); break; case ValuePredicateType.LessThanOrEqual: restriction = GetRestrictionLtEq(fieldValue, propertyExpression); break; case ValuePredicateType.GreaterThan: restriction = GetRestrictionGt(fieldValue, propertyExpression); break; case ValuePredicateType.GreaterThanOrEqual: restriction = GetRestrictionGtEq(fieldValue, propertyExpression); break; case ValuePredicateType.Contains: restriction = GetRestrictionContains(fieldValue, propertyExpression); break; case ValuePredicateType.StartsWith: restriction = GetRestrictionStarts(fieldValue, propertyExpression); break; case ValuePredicateType.EndsWith: restriction = GetRestrictionEnds(fieldValue, propertyExpression); break; } if (restriction != null) { if (numberOfMatchesEvaluated == 0) { restrictionBuilder = restriction; numberOfMatchesEvaluated++; } else { restrictionBuilder = Restrictions.Or(restriction, restrictionBuilder); } } } var fieldNameRestriction = Restrictions.Eq(Projections.Property(() => def.Alias), fieldName); if (restrictionBuilder != null) { restrictionBuilder = Restrictions.And(restrictionBuilder, fieldNameRestriction); } else { restrictionBuilder = fieldNameRestriction; } return(restrictionBuilder); }
public override IQuery VisitFieldPredicate(FieldPredicateExpression node) { var fieldName = node.SelectorExpression.FieldName; var valueKey = node.SelectorExpression.ValueKey; var fieldValue = node.ValueExpression.Value != null?node.ValueExpression.Value.ToString() : string.Empty; var c = _manager.CreateSearchCriteria(); switch (fieldName.ToLowerInvariant()) { case "id": Guid idValue = GetIdValue(node); switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: return(c.Must().Id(idValue.ToString("N"), FixedIndexedFields.EntityId).Compile()); case ValuePredicateType.NotEqual: //match all Id's (*) except... return(c.Must().Id("*").Not().Id(idValue.ToString("N"), FixedIndexedFields.EntityId).Compile()); default: throw new InvalidOperationException( "Cannot query an item by id by any other operator than == or !="); } } var attributeFieldName = FixedAttributeIndexFields.AttributePrefix + fieldName; if (!valueKey.IsNullOrWhiteSpace()) { attributeFieldName += "." + valueKey; } //now, select the field value.... switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: var query = c.Must().EntityType <TypedEntity>().Must(); if (fieldValue != string.Empty) { return(query.Field(attributeFieldName, fieldValue.Escape()).Compile()); } return(query.Field(attributeFieldName, string.Empty).Compile()); case ValuePredicateType.NotEqual: return(c.Must().EntityType <TypedEntity>() .Must() .Field(attributeFieldName, "*") .Not() .Field(attributeFieldName, fieldValue) .Compile()); case ValuePredicateType.MatchesWildcard: case ValuePredicateType.Contains: throw new NotSupportedException("Need to configure Examine to support start and end wildcards"); return(c.Must().EntityType <TypedEntity>().Must().Field(attributeFieldName, fieldValue.MultipleCharacterWildcard()).Compile()); case ValuePredicateType.StartsWith: return(c.Must().EntityType <TypedEntity>().Must().Field(attributeFieldName, fieldValue.MultipleCharacterWildcard()).Compile()); case ValuePredicateType.EndsWith: throw new NotSupportedException("Need to configure Examine to support start with wildcards"); return(c.Must().EntityType <TypedEntity>().Must().Field(attributeFieldName, fieldValue.MultipleCharacterWildcard()).Compile()); default: throw new InvalidOperationException( "This linq provider doesn't support a ClauseType of {0} for field {1}".InvariantFormat( node.ValueExpression.ClauseType.ToString(), fieldName)); } }
public override FieldFilterResult VisitFieldPredicate(FieldPredicateExpression node) { var fieldName = node.SelectorExpression.FieldName; var valueKey = node.SelectorExpression.ValueKey; var fieldValue = node.ValueExpression.Value; var fieldValueType = fieldValue != null?fieldValue.GetType() : typeof(string); var toReturn = new FieldFilterResult(); RdbmsModel.Attribute att = null; Node outerNode = null; AttributeStringValue stringVal = null; AttributeLongStringValue longStrVal = null; AttributeIntegerValue integerVal = null; AttributeDecimalValue decimalVal = null; AttributeDateValue dateVal = null; AttributeDefinition def = null; // First check for special cases, typically stuff that can be queried // that isn't necessarily a value in any of the Attribute*Value tables switch (fieldName.ToLowerInvariant()) { case "utccreated": DateTimeOffset createdDtoValue = ParseDateTimeOffset(fieldValue); if (createdDtoValue == default(DateTime)) { break; } toReturn.NhCriterion = CreateRestriction(node.ValueExpression.ClauseType, () => outerNode.DateCreated, createdDtoValue); if (toReturn.NhCriterion != null) { toReturn.Joins.Add(new Join(() => agg.Node, () => outerNode, JoinType.InnerJoin)); } break; case "utcmodified": DateTimeOffset modifiedDtoValue = ParseDateTimeOffset(fieldValue); if (modifiedDtoValue == default(DateTime)) { break; } toReturn.NhCriterion = CreateRestriction(node.ValueExpression.ClauseType, () => agg.StatusDate, modifiedDtoValue); break; case "id": Guid idValue = GetIdValue(node); switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: toReturn.NhCriterion = Restrictions.Eq(Projections.Property(() => agg.Node.Id), idValue); break; case ValuePredicateType.NotEqual: toReturn.NhCriterion = !Restrictions.Eq(Projections.Property(() => agg.Node.Id), idValue); break; default: throw new InvalidOperationException("Cannot query an item by id by any other operator than == or !="); } break; case "system-internal-selected-template": //TODO Pending property editors getting involved in query modification prior to being passed to hive provider, //manually check for queries against a template here if (valueKey == "TemplateId" && fieldValue != null) { var tryParseResult = HiveId.TryParse(fieldValue.ToString()); if (!tryParseResult.Success || tryParseResult.Result.ProviderGroupRoot == null || tryParseResult.Result.ProviderId == null || (tryParseResult.Result.ProviderGroupRoot.AbsoluteUri != "storage://" && tryParseResult.Result.ProviderId != "templates")) { var normalisedFieldValue = "/" + fieldValue.ToString().TrimStart("/").TrimEnd(".") + "."; // Need to convert the value into the serialized form that a HiveId would use var newValue = new HiveId("storage", "templates", new HiveIdValue(normalisedFieldValue)).ToString(HiveIdFormatStyle.UriSafe); fieldValue = newValue; } else { fieldValue = tryParseResult.Result.ToString(HiveIdFormatStyle.UriSafe); } } break; } if (toReturn.NhCriterion != null) { // The special-case handling above has already set the criterion, // so we don't have to evaluate field values in this pass and can return return(toReturn); } // Establish which Attribute*Value tables to query // First look up the types of the main field AttributeDefinition defAlias = null; AttributeType typeAlias = null; var attributeType = _activeSession.NhSession.QueryOver <AttributeDefinition>(() => defAlias) .JoinAlias(() => defAlias.AttributeType, () => typeAlias) .Where(() => defAlias.Alias == fieldName) .Select(Projections.Distinct(Projections.Property(() => typeAlias.PersistenceTypeProvider))) .Cacheable() .List <string>(); foreach (var type in attributeType) { var typeName = type; // Ensure we don't do unneccessary calls to Activator.CreateInstance, // (_typesAlreadyEstablished lives for the lifetime of the visitor) // but still make sure we populate the toReturn.ValueTypesToQuery for this // visit to a field predicate if (TypesAlreadyDiscovered.ContainsKey(typeName)) { var dst = TypesAlreadyDiscovered[typeName]; if (toReturn.ValueTypesToQuery.Contains(dst)) { continue; } toReturn.ValueTypesToQuery.Add(dst); } try { var persisterType = Type.GetType(typeName, false); if (persisterType != null) { var persisterInstance = Activator.CreateInstance(persisterType) as IAttributeSerializationDefinition; if (persisterInstance != null && !toReturn.ValueTypesToQuery.Contains(persisterInstance.DataSerializationType)) { toReturn.ValueTypesToQuery.Add(persisterInstance.DataSerializationType); TypesAlreadyDiscovered.TryAdd(typeName, persisterInstance.DataSerializationType); } } } catch (Exception ex) { LogHelper.Error <NhCriteriaVisitor>("Error while trying to decide which value-tables to join & query", ex); throw; } } // U5-789 // Workaround pending a better check of what data is actually saved // An issue arose because previous data had been saved in long-string, // but the datatype changed to be just string, therefore only string was // being queried despite all the data residing still in long-string if (toReturn.ValueTypesToQuery.Contains(DataSerializationTypes.String) && !toReturn.ValueTypesToQuery.Contains(DataSerializationTypes.LongString)) { toReturn.ValueTypesToQuery.Add(DataSerializationTypes.LongString); } // Now go through the types that we've found, and set up the expressions for the criteria int numberOfMatchesEvaluated = 0; AbstractCriterion restrictionBuilder = null; foreach (var dataSerializationTypese in toReturn.ValueTypesToQuery.Distinct()) { AbstractCriterion restriction = null; global::System.Linq.Expressions.Expression <Func <object> > propertyExpression = null; global::System.Linq.Expressions.Expression <Func <object> > subkeyExpression = null; List <ValuePredicateType> validClauseTypes = null; var useLikeMatchForStrings = false; switch (dataSerializationTypese) { case DataSerializationTypes.SmallInt: case DataSerializationTypes.LargeInt: case DataSerializationTypes.Boolean: propertyExpression = () => integerVal.Value; subkeyExpression = () => integerVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual }; break; case DataSerializationTypes.Decimal: propertyExpression = () => decimalVal.Value; subkeyExpression = () => decimalVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual }; break; case DataSerializationTypes.String: propertyExpression = () => stringVal.Value; subkeyExpression = () => stringVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.NotEqual, ValuePredicateType.Contains, ValuePredicateType.StartsWith, ValuePredicateType.EndsWith, ValuePredicateType.MatchesWildcard }; break; case DataSerializationTypes.LongString: propertyExpression = () => longStrVal.Value; subkeyExpression = () => longStrVal.ValueKey; useLikeMatchForStrings = true; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.NotEqual, ValuePredicateType.Contains, ValuePredicateType.StartsWith, ValuePredicateType.EndsWith, ValuePredicateType.MatchesWildcard }; break; case DataSerializationTypes.Date: propertyExpression = () => dateVal.Value; subkeyExpression = () => dateVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual, ValuePredicateType.Empty }; break; } if (!validClauseTypes.Contains(node.ValueExpression.ClauseType)) { throw new InvalidOperationException("A field of type {0} cannot be queried with operator {1}".InvariantFormat(dataSerializationTypese.ToString(), node.ValueExpression.ClauseType.ToString())); } // Based on the clause type, generate an NH criterion switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: restriction = GetRestrictionEq(fieldValue, useLikeMatchForStrings, propertyExpression, subkeyExpression, valueKey); break; case ValuePredicateType.NotEqual: restriction = !GetRestrictionEq(fieldValue, useLikeMatchForStrings, propertyExpression); break; case ValuePredicateType.LessThan: restriction = GetRestrictionLt(fieldValue, propertyExpression); break; case ValuePredicateType.LessThanOrEqual: restriction = GetRestrictionLtEq(fieldValue, propertyExpression); break; case ValuePredicateType.GreaterThan: restriction = GetRestrictionGt(fieldValue, propertyExpression); break; case ValuePredicateType.GreaterThanOrEqual: restriction = GetRestrictionGtEq(fieldValue, propertyExpression); break; case ValuePredicateType.Contains: restriction = GetRestrictionContains(fieldValue, propertyExpression); break; case ValuePredicateType.StartsWith: restriction = GetRestrictionStarts(fieldValue, propertyExpression); break; case ValuePredicateType.EndsWith: restriction = GetRestrictionEnds(fieldValue, propertyExpression); break; } // We might be dealing with multiple restrictions even for one field (e.g. if it's been stored once in String table, and another time in LongString) if (restriction != null) { if (numberOfMatchesEvaluated == 0) { restrictionBuilder = restriction; numberOfMatchesEvaluated++; } else { // If we're doing a second or later evaluation, turn the restriction into an Or to combine them all restrictionBuilder = Restrictions.Or(restriction, restrictionBuilder); } } } // Add the field name restriction var fieldNameRestriction = Restrictions.Eq(Projections.Property(() => def.Alias), fieldName); if (restrictionBuilder != null) { restrictionBuilder = Restrictions.And(restrictionBuilder, fieldNameRestriction); } else { restrictionBuilder = fieldNameRestriction; } // Build the query which will use the restrictions we've just generated var query = QueryOver.Of(() => agg); // Set up the basic joins (not that we're adding these to a Joins collection on our own type, not just doing // them on an NH query, so that we can optimise or merge the joins once the entire expression tree is evaluated // for example inside VisitBinary) toReturn.Joins.Add(new Join(() => agg.NodeVersion, () => version, JoinType.InnerJoin)); toReturn.Joins.Add(new Join(() => version.Attributes, () => att, JoinType.InnerJoin)); toReturn.Joins.Add(new Join(() => att.AttributeDefinition, () => def, JoinType.InnerJoin)); // Set up the joins for the value tables - only add joins for the tables that we know we want to actually query based on // what VisitField might have encountered and added to toReturn.ValueTypesToQuery foreach (var dataSerializationTypese in toReturn.ValueTypesToQuery.Distinct()) { Expression <Func <object> > path = null; Expression <Func <object> > alias = null; switch (dataSerializationTypese) { case DataSerializationTypes.SmallInt: case DataSerializationTypes.LargeInt: case DataSerializationTypes.Boolean: path = () => att.AttributeIntegerValues; alias = () => integerVal; break; case DataSerializationTypes.Decimal: path = () => att.AttributeDecimalValues; alias = () => decimalVal; break; case DataSerializationTypes.String: path = () => att.AttributeStringValues; alias = () => stringVal; break; case DataSerializationTypes.LongString: path = () => att.AttributeLongStringValues; alias = () => longStrVal; break; case DataSerializationTypes.Date: path = () => att.AttributeDateValues; alias = () => dateVal; break; } toReturn.Joins.Add(new Join(path, alias)); } toReturn.Subquery = query .Where(restrictionBuilder) .Select(x => x.NodeVersion.Id); toReturn.NhCriterion = restrictionBuilder; return(toReturn); }
public override Expression VisitFieldPredicate(FieldPredicateExpression node) { StringBuilder.AppendFormat("\n{0}", node); return(node); }