protected virtual QueryNode VisitLike(LikeNode node, ElasticSearchQueryOptimizerState state) { state.Boost = 1f; var node2 = Visit(node.LeftNode, state); return(new LikeNode(node2, Visit(node.RightNode, state), node.MinimumSimilarity, state.Boost)); }
void BuildSql(LikeNode node) { if (node.Method == LikeMethod.Equals) { _builder.AddCondition(node.MemberNode.TableName, node.MemberNode.FieldName, _operationDictionary[ExpressionType.Equal], node.Value); } else { string value = node.Value; switch (node.Method) { case LikeMethod.StartsWith: value = node.Value + _builder.Adapter.LikeChars(); break; case LikeMethod.EndsWith: value = _builder.Adapter.LikeChars() + node.Value; break; case LikeMethod.Contains: value = _builder.Adapter.LikeChars() + node.Value + _builder.Adapter.LikeChars(); break; } _builder.AddLikeCondition(node.MemberNode.TableName, node.MemberNode.FieldName, value); } }
private void BuildSql(LikeNode node) { var value = string.Empty; switch (node.Method) { case LikeMethod.StartsWith: value = node.Value + "%"; break; case LikeMethod.EndsWith: value = "%" + node.Value; break; case LikeMethod.Like: case LikeMethod.Contains: value = "%" + node.Value + "%"; break; case LikeMethod.Equals: QueryByField(node.MemberNode.TableName, node.MemberNode.FieldName, operationDictionary[ExpressionType.Equal], node.Value); break; default: throw new ArgumentOutOfRangeException(); } QueryByFieldLike(node.MemberNode.TableName, node.MemberNode.FieldName, value); }
private void BuildSql(LikeNode node) { if (node.Method == LikeMethod.Equals) { QueryByField(node.MemberNode.TableName, node.MemberNode.FieldName, Helpers.Helper.GetOperator(ExpressionType.Equal), node.Value); } else { string value = node.Value; switch (node.Method) { case LikeMethod.StartsWith: value = node.Value + "%"; break; case LikeMethod.EndsWith: value = "%" + node.Value; break; case LikeMethod.Contains: value = "%" + node.Value + "%"; break; } QueryByFieldLike(node.MemberNode.TableName, node.MemberNode.FieldName, value); } }
void BuildSql(LikeNode node) { if (node.Method == LikeMethod.Equals) { _builder.QueryByField(node.MemberNode.TableName, node.MemberNode.FieldName, _operationDictionary[ExpressionType.Equal], node.Value); } else { string value = node.Value; switch (node.Method) { case LikeMethod.StartsWith: value = node.Value + "%"; break; case LikeMethod.EndsWith: value = "%" + node.Value; break; case LikeMethod.Contains: value = "%" + node.Value + "%"; break; } _builder.QueryByFieldLike(node.MemberNode.TableName, node.MemberNode.FieldName, value); } }
public void RegexSingleCharacterWildcardLiteral() { string regex = LikeNode.ConvertLikeToRegex("b[_]n"); Assert.IsTrue(LikeNode.IsRegexMatch("b_n", regex)); Assert.IsFalse(LikeNode.IsRegexMatch("bin", regex)); }
protected QueryBase VisitLike(LikeNode node, ElasticQueryMapperState state) { // TODO: Move these 3 lines to separate method for reuse? var fieldName = GetFormattedFieldName(node); var valueNode = node.GetValueNode <string>(); var value = ValueFormatter.FormatValueForIndexStorage(valueNode.Value, fieldName); // TODO: Match/MatchPhrase? /* Like the match query, the match_phrase query first analyzes the query string to produce a list of terms. * It then searches for all the terms, but keeps only documents that contain all of the search terms, * in the same positions relative to each other. */ var query = new MatchQuery { Field = fieldName, Query = value.ToStringOrEmpty(), Boost = node.Boost, // TODO: Not sure if this is the best way to handle slop/similarity. // Use EditDistance if Slop > 0, otherwise use Ratio if MinimumSimilarity > 0 and not default, otherwise Auto Fuzziness = node.Slop > 0 ? Fuzziness.EditDistance(node.Slop) : node.MinimumSimilarity > 0 && node.MinimumSimilarity != 0.5f ? Fuzziness.Ratio(node.MinimumSimilarity) : Fuzziness.Auto }; return(query); }
public void Visit(LikeNode node) { var right = Nodes.Pop(); var left = Nodes.Pop(); Nodes.Push(new LikeNode(left, right)); }
public LikeNode Like(string value) { LikeNode likeNode = new LikeNode(); Match(TokenType.LIKE); return(likeNode); }
public void RegexBeginsWithConversion() { string regex = LikeNode.ConvertLikeToRegex("abc%"); Assert.IsTrue(LikeNode.IsRegexMatch("abcdef", regex)); Assert.IsFalse(LikeNode.IsRegexMatch("123abcdef", regex)); Assert.IsFalse(LikeNode.IsRegexMatch("123abc", regex)); }
public void RegexPercentLiteral2() { string regex = LikeNode.ConvertLikeToRegex("%e[%]"); Assert.IsTrue(LikeNode.IsRegexMatch("be%", regex)); Assert.IsTrue(LikeNode.IsRegexMatch("e%", regex)); Assert.IsFalse(LikeNode.IsRegexMatch("e%d", regex)); }
public void RegexEndsWithConversion() { string regex = LikeNode.ConvertLikeToRegex("%def"); Assert.IsTrue(LikeNode.IsRegexMatch("abcdef", regex)); Assert.IsFalse(LikeNode.IsRegexMatch("abcdef123", regex)); Assert.IsFalse(LikeNode.IsRegexMatch("def123", regex)); }
public void RegexContains() { string regex = LikeNode.ConvertLikeToRegex("%bcd%"); Assert.IsTrue(LikeNode.IsRegexMatch("abcdef", regex)); Assert.IsTrue(LikeNode.IsRegexMatch("bcdef", regex)); Assert.IsTrue(LikeNode.IsRegexMatch("abcd", regex)); Assert.IsTrue(LikeNode.IsRegexMatch("bcd", regex)); Assert.IsFalse(LikeNode.IsRegexMatch("def", regex)); }
public void Visit(LikeNode node) { Visit(new FunctionNode(nameof(Operators.Like), new ArgsListNode(new[] { node.Left, node.Right }), new string[0], new Traficante.TSQL.Schema.Managers.MethodInfo { FunctionMethod = typeof(Operators).GetMethod(nameof(Operators.Like)) })); //node.Left.Accept(this); //node.Right.Accept(this); //node.Accept(_visitor); }
protected BaseQuery HandleLike(LikeNode node, ElasticSearchQueryMapperState mappingState) { var fieldName = GetFormattedFieldName(node); var valueNode = QueryHelper.GetValueNode <string>(node); var formattedValue = ValueFormatter.FormatValueForIndexStorage(valueNode.Value); var query = Query.Fuzzy( descriptor => descriptor.OnField(fieldName) .MinSimilarity(node.MinimumSimilarity) .Like(formattedValue.ToStringOrEmpty()) .Boost(node.Boost)); return(query); }
private void Build(LikeNode node) { if (node.Method == LikeMethod.Equals) { QueryFieldCondition(node.MemberNode, SqlFormatter.Operations[ExpressionType.Equal], node.Value); } else { var value = SqlFormatter.LikeCondition(node.Value, node.Method); var paramId = ContextBase.NextParamId(); var newCondition = SqlFormatter.FieldLike(node.MemberNode, paramId); ContextBase.Conditions.Add(newCondition); ContextBase.AddParameter(paramId, value); } }
public void BuildWhere(LikeNode node) { object v = node.Value; string sv = node.Value.ToString(); switch (node.Method) { case SqlLikeType.StartsWith: v = sv + LikeSymbol; break; case SqlLikeType.EndsWith: v = LikeSymbol + sv; break; case SqlLikeType.Contains: v = LikeSymbol + sv + LikeSymbol; break; } AddCondition(node.MemberNode.TableName, node.MemberNode.FieldName, _methods[node.Method], v); }
private Node ResolveQuery(MethodCallExpression callExpression) { var functionParsed = Enum.TryParse(callExpression.Method.Name, true, out LikeMethod callFunction); if (functionParsed) { var memberExpression = callExpression.Object as MemberExpression; var argumentFunction = callExpression.Arguments.First(); var columnValue = (string)_lambdaResolverExtension.GetExpressionValue(argumentFunction); var tableName = LambdaResolverExtension.GetTableName(memberExpression); var columnName = SqlBuilderFluentHelper.GetColumnName(callExpression.Object); var memberNode = new MemberNode(tableName, columnName); var likeNode = new LikeNode(callFunction, memberNode, columnValue); return(likeNode); } else { var value = _lambdaResolverExtension.ResolveMethodCall(callExpression); var valueNode = new ValueNode(value); return(valueNode); } }
public void RegexNoWildcard() { string regex = LikeNode.ConvertLikeToRegex("bcd"); Assert.IsFalse(LikeNode.IsRegexMatch("abcdef", regex)); }
public void Visit(LikeNode node) { node.Left.Accept(this); node.Right.Accept(this); node.Accept(_visitor); }
public void Visit(LikeNode node) { }
protected virtual QueryNode VisitLike(LikeNode node, AzureQueryOptimizerState state) { return((QueryNode) new LikeNode(this.Visit(node.LeftNode, state), this.Visit(node.RightNode, state), node.MinimumSimilarity, node.Slop, state.Boost)); }