protected internal override Expression VisitLike(LikeExpression like)
{
Visit(like.Expression);
sb.Append(" LIKE ");
Visit(like.Pattern);
return(like);
}
protected override Expression VisitLike(LikeExpression likeExpression)
{
Visit(likeExpression.Match);
Visit(likeExpression.Pattern);
return(likeExpression);
}
public void TestCloneLikeExpression()
{
LikeExpression likeExpression = new LikeExpression()
{
Left = new ColumnReference()
{
Identifiers = new List <string>()
{
"c1"
}
},
Right = new StringLiteral()
{
Value = "test"
},
Not = false
};
var clone = likeExpression.Clone() as LikeExpression;
Assert.AreEqual(likeExpression, clone);
Assert.IsFalse(ReferenceEquals(likeExpression, clone));
Assert.IsFalse(ReferenceEquals(likeExpression.Left, clone.Left));
Assert.IsFalse(ReferenceEquals(likeExpression.Right, clone.Right));
}
public QueryBuilder <T> Like(object value)
{
AbstractCriterion likeExpression = new LikeExpression(name, value);
AddCriterion(likeExpression);
return(this);
}
void HandleStringEndsWithExpression(LikeExpression likeExpression)
{
Expression right = ((BinaryExpression)likeExpression.Pattern).Right;
string text = " LOCATE (";
if (right.NodeType == ExpressionType.Constant || right.NodeType == ExpressionType.Parameter)
{
Visit(likeExpression.Match);
Sql.Append(" LIKE ");
Visit(likeExpression.Pattern);
}
else
{
Sql.Append(text);
Visit(right);
Sql.Append(" , RIGHT( ");
Visit(likeExpression.Match);
Sql.Append(" , ( LENGTH(");
Visit(likeExpression.Match);
Sql.Append(") + 1) - " + text);
Visit(right);
Sql.Append(" , ");
Visit(likeExpression.Match);
Sql.Append(" ))) = cast(1 AS int)");
}
}
protected override Expression VisitLike(QueryTranslatorContext context, LikeExpression expression)
{
// Is the left side a collection?
if (expression.Left is CollectionExpression collection)
{
// Build the collection accessor parameter.
var parameter = collection.Accept(this, context);
// Build the predicate expression.
context.PushParameter(collection.ItemType);
var predicate = Expression.Lambda(
new LikeExpression(
collection.ItemAccessor,
expression.Right).Accept(this, context),
context.Parameter);
context.PopParameter();
// We need to use an Enumerable.Any together with the LIKE predicate.
return(Expression.Call(typeof(Enumerable), "Any", new Type[] { collection.ItemType }, parameter, predicate));
}
var left = expression.Left.Accept(this, context);
var right = expression.Right.Accept(this, context);
return(Expression.Call(
null, typeof(DbFunctionsExtensions).GetMethod("Like", new[] { typeof(DbFunctions), typeof(string), typeof(string) }),
Expression.Constant(EF.Functions), left, right));
}
public void Visit(LikeExpression op)
{
var leftArgs = VisitChild(op.Left);
var rightArgs = VisitChild(op.Right);
_codeStack.Peek().CodeExpression = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Helper)), "Like", leftArgs.CodeExpression, rightArgs.CodeExpression);
}
public QueryBuilder <T> Like(string value, MatchMode matchMode)
{
AbstractCriterion likeExpression = new LikeExpression(name, value, matchMode);
AddCriterion(likeExpression);
return(this);
}
public void Visit(LikeExpression expression)
{
var searchString = expression.SearchString;
var columnName = expression.PropertyExpression.PropertyName;
var actualValue = (string)_row.GetColumnValue(columnName).Value;
Func <string, bool> operation;
if (expression.HasStartingWildCard && expression.HasEndingWildCard)
{
operation = actualValue.Contains;
}
else if (expression.HasStartingWildCard)
{
operation = actualValue.EndsWith;
}
else if (expression.HasEndingWildCard)
{
operation = actualValue.StartsWith;
}
else
{
throw new WeenyMapperException("Invalid like expression for column '{0}' and search string '{1}'", columnName, searchString);
}
if (!operation(searchString))
{
_isMatch = false;
}
}
public void TestLikeExpressionAccept()
{
Mock <KoraliumSqlVisitor> mock = new Mock <KoraliumSqlVisitor>();
LikeExpression likeExpression = new LikeExpression();
likeExpression.Accept(mock.Object);
mock.Verify(x => x.VisitLikeExpression(likeExpression));
}
public override Expression VisitLike(LikeExpression likeExpression)
{
Visit(likeExpression.Match);
Sql.Append(" LIKE ('%' ");
Visit(likeExpression.Pattern);
Sql.Append(" '%')");
return(likeExpression);
}
/// <summary>
/// 访问Like表达式。
/// </summary>
/// <param name="likeExpression">表达式实例。</param>
/// <returns>返回访问后的表达式实例对象。</returns>
public virtual Expression VisitLike(LikeExpression likeExpression)
{
Check.NotNull(likeExpression, nameof(likeExpression));
Visit(likeExpression.Match);
_builder.Append(" LIKE ");
Visit(likeExpression.Pattern);
return(likeExpression);
}
protected internal virtual Expression VisitLike(LikeExpression like)
{
Expression exp = Visit(like.Expression);
Expression pattern = Visit(like.Pattern);
if (exp != like.Expression || pattern != like.Pattern)
{
return(new LikeExpression(exp, pattern));
}
return(like);
}
public bool Filters(LikeExpression like)
{
//TODO: Enhancement - evaluate Like Pattern for superset/subset conditions.
//e.g., "*" would filter "?*", or "?*" would filter "a*"
//They go here...
if (like.Operand.Equals(Operand) && Pattern.Equals($"\"*\"")) //The easiest one
{
return(true);
}
return(false);
}
public void String_EndsWith_call_is_parsed_into_like_expression_with_only_starting_wildcard()
{
var expression = _parser.Parse <Book>(x => x.AuthorName.EndsWith("Steve"));
var expectedExpression = new LikeExpression(new PropertyExpression("AuthorName", typeof(string)), "Steve")
{
HasStartingWildCard = true,
HasEndingWildCard = false
};
Assert.AreEqual(expectedExpression, expression);
}
public virtual Expression VisitLikeExpression(LikeExpression likeExpression)
{
Check.NotNull(likeExpression, "likeExpression");
VisitExpression(likeExpression.Match);
_sql.Append(" LIKE ");
VisitExpression(likeExpression.Pattern);
return(likeExpression);
}
private SqlExpression ApplyTypeMappingOnLike(LikeExpression likeExpression)
{
var inferredTypeMapping = ExpressionExtensions.InferTypeMapping(
likeExpression.Match, likeExpression.Pattern, likeExpression.EscapeChar)
?? _typeMappingSource.FindMapping(likeExpression.Match.Type);
return(new LikeExpression(
ApplyTypeMapping(likeExpression.Match, inferredTypeMapping),
ApplyTypeMapping(likeExpression.Pattern, inferredTypeMapping),
ApplyTypeMapping(likeExpression.EscapeChar, inferredTypeMapping),
_boolTypeMapping));
}
private LikeExpression VisitLikeExpression(LikeExpression likeExpression)
{
var newMatch = (SqlExpression)Visit(likeExpression.Match);
var isNullable = _isNullable;
var newPattern = (SqlExpression)Visit(likeExpression.Pattern);
isNullable |= _isNullable;
var newEscapeChar = (SqlExpression)Visit(likeExpression.EscapeChar);
_isNullable |= isNullable;
return(likeExpression.Update(newMatch, newPattern, newEscapeChar));
}
public void LikeMissingAtSymb()
{
LikeExpression expression = null;
Dictionary <string, object> parameters = null;
string whereParam = null;
expression = Expression.LikeValue("testtest");
parameters = expression.GetDynamicParameters("p1");
whereParam = expression.ToSqlExpression("[Table].[Field]", "p1");
Assert.AreEqual(parameters["p1"], "testtest");
Assert.AreEqual(whereParam, " and [Table].[Field] like @p1");
}
protected override Expression VisitLike(LikeExpression likeExpression)
{
var parentSearchCondition = _isSearchCondition;
_isSearchCondition = false;
var match = (SqlExpression)Visit(likeExpression.Match);
var pattern = (SqlExpression)Visit(likeExpression.Pattern);
var escapeChar = (SqlExpression)Visit(likeExpression.EscapeChar);
_isSearchCondition = parentSearchCondition;
return(ApplyConversion(likeExpression.Update(match, pattern, escapeChar), condition: true));
}
public override void VisitLikeExpression(LikeExpression likeExpression)
{
LikeVisitor likeVisitor = new LikeVisitor(_previousStage, _visitorMetadata);
likeExpression.Accept(likeVisitor);
//Add the properties that was found in the like visitor
foreach (var usedProperty in likeVisitor.UsedProperties)
{
AddUsedProperty(usedProperty);
}
expressions.Push(likeVisitor.Expression);
}
protected override Expression VisitLike(LikeExpression likeExpression)
{
Visit(likeExpression.Match);
_relationalCommandBuilder.Append(" LIKE ");
Visit(likeExpression.Pattern);
if (likeExpression.EscapeChar != null)
{
_relationalCommandBuilder.Append(" ESCAPE ");
Visit(likeExpression.EscapeChar);
}
return(likeExpression);
}
/// <summary>
/// Visit a LikeExpression.
/// </summary>
/// <param name="likeExpression"> The like expression. </param>
/// <returns>
/// An Expression.
/// </returns>
public override Expression VisitLike(LikeExpression likeExpression)
{
Check.NotNull(likeExpression, nameof(likeExpression));
if (likeExpression.EscapeChar != null)
{
base.VisitLike(new LikeExpression(likeExpression.Match, likeExpression.Pattern));
}
else
{
base.VisitLike(likeExpression);
}
return(likeExpression);
}
protected override Expression VisitLike(LikeExpression likeExpression)
{
Check.NotNull(likeExpression, nameof(likeExpression));
var parentOptimize = _optimize;
_optimize = false;
var match = (SqlExpression)Visit(likeExpression.Match);
var pattern = (SqlExpression)Visit(likeExpression.Pattern);
var escapeChar = (SqlExpression)Visit(likeExpression.EscapeChar);
_optimize = parentOptimize;
return(ApplyConversion(likeExpression.Update(match, pattern, escapeChar), condition: true));
}
/// <summary>
/// Visit a LikeExpression.
/// </summary>
/// <param name="likeExpression"> The like expression. </param>
/// <returns>
/// An Expression.
/// </returns>
protected override Expression VisitLike(LikeExpression likeExpression)
{
Check.NotNull(likeExpression, nameof(likeExpression));
if (likeExpression.EscapeChar != null)
{
base.VisitLike(_sqlExpressionFactory.Like(likeExpression.Match, likeExpression.Pattern));
}
else
{
base.VisitLike(likeExpression);
}
return(likeExpression);
}
public override void VisitLikeExpression(LikeExpression likeExpression)
{
likeExpression.Left.Accept(this);
var leftExpression = PopStack();
var visitResult = VisitInternal(likeExpression.Right);
Expression expression = null;
if (visitResult.StartsWith && visitResult.EndsWith)
{
expression = PredicateUtils.CallContains(
leftExpression,
visitResult.Expression,
_visitorMetadata.OperationsProvider);
}
//Starts with
else if (visitResult.StartsWith)
{
expression = PredicateUtils.CallStartsWith(
leftExpression,
visitResult.Expression,
_visitorMetadata.OperationsProvider);
}
//Ends with
else if (visitResult.EndsWith)
{
expression = PredicateUtils.CallEndsWith(
leftExpression,
visitResult.Expression,
_visitorMetadata.OperationsProvider);
}
else
{
expression = PredicateUtils.CreateComparisonExpression(
leftExpression,
visitResult.Expression,
BooleanComparisonType.Equals,
_visitorMetadata.OperationsProvider);
}
if (likeExpression.Not)
{
expression = Expression.Not(expression);
}
AddExpressionToStack(expression);
}
public virtual Expression VisitLike(LikeExpression likeExpression)
{
Check.NotNull(likeExpression, nameof(likeExpression));
var parentIsUnicode = _isUnicode;
_isUnicode = InferUnicodeFromColumn(likeExpression.Match) ?? _isUnicode;
Visit(likeExpression.Match);
_relationalCommandBuilder.Append(" LIKE ");
Visit(likeExpression.Pattern);
_isUnicode = parentIsUnicode;
return(likeExpression);
}
public void TestVisitLikeExpression()
{
Mock <ScalarExpression> left = new Mock <ScalarExpression>();
Mock <ScalarExpression> right = new Mock <ScalarExpression>();
LikeExpression likeExpression = new LikeExpression()
{
Left = left.Object,
Right = right.Object
};
KoraliumSqlVisitor koraliumSqlVisitor = new KoraliumSqlVisitor();
koraliumSqlVisitor.Visit(likeExpression);
left.Verify(x => x.Accept(koraliumSqlVisitor));
right.Verify(x => x.Accept(koraliumSqlVisitor));
}
void HandleStringStartsWithExpression(LikeExpression likeExpression)
{
Expression left = ((BinaryExpression)likeExpression.Pattern).Left;
if (left.NodeType == ExpressionType.Constant || left.NodeType == ExpressionType.Parameter)
{
Visit(likeExpression.Match);
Sql.Append(" LIKE ");
Visit(likeExpression.Pattern);
}
else
{
Sql.Append(" LOCATE (");
Visit(left);
Sql.Append(" , ");
Visit(likeExpression.Match);
Sql.Append(" ) = cast(1 AS int)");
}
}
void HandleStringContainExpression(LikeExpression likeExpression)
{
Expression expression = VisitLikeExpression((BinaryExpression)likeExpression.Pattern);
if (expression.NodeType == ExpressionType.Constant || expression.NodeType == ExpressionType.Parameter)
{
Visit(likeExpression.Match);
Sql.Append(" LIKE '%' || ");
Visit(expression);
Sql.Append(" || '%'");
}
else
{
Sql.Append(" LOCATE (");
Visit(expression);
Sql.Append(" , ");
Visit(likeExpression.Match);
Sql.Append(" ) >= cast(1 AS int)");
}
}
public void Visit(LikeExpression expression)
{
var searchString = expression.SearchString;
var columnName = expression.PropertyExpression.PropertyName;
var actualValue = (string)_row.GetColumnValue(columnName).Value;
Func<string, bool> operation;
if (expression.HasStartingWildCard && expression.HasEndingWildCard)
{
operation = actualValue.Contains;
}
else if (expression.HasStartingWildCard)
{
operation = actualValue.EndsWith;
}
else if (expression.HasEndingWildCard)
{
operation = actualValue.StartsWith;
}
else
{
throw new WeenyMapperException("Invalid like expression for column '{0}' and search string '{1}'", columnName, searchString);
}
if (!operation(searchString))
_isMatch = false;
}
protected override Expression VisitLike(LikeExpression like)
{
Visit(like.Expression);
sb.Append(" LIKE ");
Visit(like.Pattern);
return like;
}
private string GetExpression(LikeExpression expression, ref List<OleDbParameter> parameters)
{
return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " Like " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ";
}
public void String_StartsWith_call_is_parsed_into_like_expression_with_only_ending_wildcard()
{
var expression = _parser.Parse<Book>(x => x.AuthorName.StartsWith("Steve"));
var expectedExpression = new LikeExpression(new PropertyExpression("AuthorName", typeof(string)), "Steve")
{
HasStartingWildCard = false,
HasEndingWildCard = true
};
Assert.AreEqual(expectedExpression, expression);
}
protected virtual Expression VisitLike(LikeExpression like)
{
Expression exp = Visit(like.Expression);
Expression pattern = Visit(like.Pattern);
if (exp != like.Expression || pattern != like.Pattern)
return new LikeExpression(exp, pattern);
return like;
}