protected override void OnModelCreating(ModelBuilder modelBuilder) { base.OnModelCreating(modelBuilder); // IsDate is a built-in SQL Server function, that in the base class is mapped as built-in, which means we // don't get any quotes. We remap it as non-built-in by including a (null) schema. var isDateMethodInfo = typeof(UDFSqlContext).GetMethod(nameof(IsDateStatic)); modelBuilder.HasDbFunction(isDateMethodInfo) .HasTranslation(args => SqlFunctionExpression.Create((string)null, "IsDate", args, isDateMethodInfo.ReturnType, null)); var isDateMethodInfo2 = typeof(UDFSqlContext).GetMethod(nameof(IsDateInstance)); modelBuilder.HasDbFunction(isDateMethodInfo2) .HasTranslation(args => SqlFunctionExpression.Create((string)null, "IsDate", args, isDateMethodInfo2.ReturnType, null)); // Base class maps to len(), but in PostgreSQL it's called length() var methodInfo = typeof(UDFSqlContext).GetMethod(nameof(MyCustomLengthStatic)); modelBuilder.HasDbFunction(methodInfo) .HasTranslation(args => SqlFunctionExpression.Create("length", args, methodInfo.ReturnType, null)); var methodInfo2 = typeof(UDFSqlContext).GetMethod(nameof(MyCustomLengthInstance)); modelBuilder.HasDbFunction(methodInfo2) .HasTranslation(args => SqlFunctionExpression.Create("length", args, methodInfo2.ReturnType, null)); }
protected override void OnModelCreating(ModelBuilder modelBuilder) { //TODO: Map Composite Keys Entities Here //TODO: Set the .HasNoKey() to views and stored procedures //This lines map a DB funcion so we can call it inside the linq or lambda function that executes a query to the DB modelBuilder.HasDbFunction(typeof(SampleDataContextFunctions).GetMethod(nameof(SampleDataContextFunctions.CalcuateAgeInYearsMonths))) .HasTranslation(args => SqlFunctionExpression.Create("dbo", "f_CalcuateAgeInYearsMonths", args, typeof(decimal?), null)); //Disable the cascade delete behavior var cascadeFKs = modelBuilder.Model.GetEntityTypes().SelectMany(t => t.GetForeignKeys()) .Where(fk => !fk.IsOwnership && fk.DeleteBehavior == DeleteBehavior.Cascade); foreach (var fk in cascadeFKs) { fk.DeleteBehavior = DeleteBehavior.Restrict; } modelBuilder.Ignore <ExtensionDataObject>(); base.OnModelCreating(modelBuilder); }
public void Transform_TwoArguments() { var method = typeof(StringExtensions).GetMethod( "SqlContainsFulltext", BindingFlags.Public | BindingFlags.Static, null, CallingConventions.Any, new[] { typeof(string), typeof(string), typeof(string) }, null); var objectExpression = Expression.Constant("Test"); var argument1 = Expression.Constant("es"); var language = Expression.Constant("language"); var expression = Expression.Call(method, objectExpression, argument1, language); var transformer = new ContainsFulltextMethodCallTransformer(); var result = transformer.Transform(expression); var argumentExpression = Expression.Constant(string.Format("{0}", argument1.Value)); var compositeExpression = new SqlCompositeCustomTextGeneratorExpression( typeof(string), new SqlCustomTextExpression("LANGUAGE ", typeof(string)), language); var expectedResult = new SqlFunctionExpression(typeof(bool), "CONTAINS", objectExpression, argumentExpression, compositeExpression); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result); }
public virtual SqlFunctionExpression Function( SqlExpression instance, string name, IEnumerable<SqlExpression> arguments, bool nullResultAllowed, bool instancePropagatesNullability, IEnumerable<bool> argumentsPropagateNullability, Type returnType, RelationalTypeMapping typeMapping = null) { Check.NotEmpty(name, nameof(name)); Check.NotNull(arguments, nameof(arguments)); Check.NotNull(returnType, nameof(returnType)); instance = ApplyDefaultTypeMapping(instance); var typeMappedArguments = new List<SqlExpression>(); foreach (var argument in arguments) { typeMappedArguments.Add(ApplyDefaultTypeMapping(argument)); } return SqlFunctionExpression.Create( instance, name, typeMappedArguments, nullResultAllowed, instancePropagatesNullability, argumentsPropagateNullability, returnType, typeMapping); }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> protected override Expression VisitSqlFunction(SqlFunctionExpression sqlFunctionExpression) { Check.NotNull(sqlFunctionExpression, nameof(sqlFunctionExpression)); if (!sqlFunctionExpression.IsBuiltIn && string.IsNullOrEmpty(sqlFunctionExpression.Schema)) { sqlFunctionExpression = sqlFunctionExpression.IsNiladic ? new SqlFunctionExpression( schema: "dbo", sqlFunctionExpression.Name, sqlFunctionExpression.IsNullable, sqlFunctionExpression.Type, sqlFunctionExpression.TypeMapping) : new SqlFunctionExpression( schema: "dbo", sqlFunctionExpression.Name, sqlFunctionExpression.Arguments, sqlFunctionExpression.IsNullable, sqlFunctionExpression.ArgumentsPropagateNullability, sqlFunctionExpression.Type, sqlFunctionExpression.TypeMapping); } return(base.VisitSqlFunction(sqlFunctionExpression)); }
public virtual SqlFunctionExpression Function(string name, bool nullResultAllowed, Type returnType, RelationalTypeMapping typeMapping = null) { Check.NotEmpty(name, nameof(name)); Check.NotNull(returnType, nameof(returnType)); return SqlFunctionExpression.CreateNiladic(name, nullResultAllowed, returnType, typeMapping); }
protected override Expression VisitSqlFunction(SqlFunctionExpression sqlFunctionExpression) { if (sqlFunctionExpression.IsBuiltIn) { if (sqlFunctionExpression.Instance != null) { Visit(sqlFunctionExpression.Instance); Sql.Append("."); } Sql.Append(sqlFunctionExpression.Name); } else { if (!string.IsNullOrEmpty(sqlFunctionExpression.Schema)) { Sql .Append(_sqlGenerationHelper.DelimitIdentifier(sqlFunctionExpression.Schema)) .Append("."); } Sql .Append(_sqlGenerationHelper.DelimitIdentifier(sqlFunctionExpression.Name)); } if (!sqlFunctionExpression.IsNiladic) { Sql.Append("("); GenerateList(sqlFunctionExpression.Arguments, e => Visit(e)); Sql.Append(")"); } return(sqlFunctionExpression); }
protected override void OnModelCreating(ModelBuilder modelBuilder) { modelBuilder.Entity <TableA>(); modelBuilder.HasDbFunction(typeof(TestDataBaseContext).GetMethod(nameof(JsonValue))) .HasTranslation(args => SqlFunctionExpression.Create("JSON_VALUE", args, typeof(string), null)); }
public override Expression VisitSqlFunction(SqlFunctionExpression sqlFunctionExpression) { var expr = base.VisitSqlFunction(sqlFunctionExpression); // Note that PostgreSQL COUNT(*) is BIGINT (64-bit). For 32-bit Count() expressions we cast. if (sqlFunctionExpression.FunctionName == "COUNT" && sqlFunctionExpression.Type == typeof(int)) { Sql.Append("::INT4"); return(expr); } // In PostgreSQL SUM() doesn't return the same type as its argument for smallint, int and bigint. // Cast to get the same type. // http://www.postgresql.org/docs/current/static/functions-aggregate.html if (sqlFunctionExpression.FunctionName == "SUM") { if (sqlFunctionExpression.Type == typeof(int)) { Sql.Append("::INT4"); } else if (sqlFunctionExpression.Type == typeof(short)) { Sql.Append("::INT2"); } return(expr); } return(expr); }
public static SqlFunctionExpression Function <TRet>(string schema, string name, IEnumerable <SqlExpression> arguments) { var returnType = typeof(TRet); var typeMapping = GetTypeMapping(returnType); return(SqlFunctionExpression.Create(schema, name, arguments, returnType, typeMapping)); }
public override SelectExpression PreviewSelect(SelectExpression select, LockType lockType) { select = base.PreviewSelect(select, lockType); // Use TOP if there's limit, no offset, and there's no order by - to exclude search queries; // searches do have OrderBy, and for searches we want to use standard clause with Skip-Offset if (select.Limit != null && (select.Offset == null || Linq.LinqExpressionHelper.IsConstZero(select.Offset)) && select.OrderBy.Count == 0) { select.Flags |= SelectExpressionFlags.MsSqlUseTop; // Fake order-by is needed only with full Fetch Next/Offset syntax select.Flags &= ~SelectExpressionFlags.NeedsFakeOrderBy; } // SQL Server does not allow bool values in SELECT list. For ex, the following results in error: // SELECT (book.Price > 10) AS OverPriced, ..... // So we need to find output exprs like this and wrap them like: // SELECT IIF(book.Price > 10, 1, 0) AS OverPriced, ... for (int i = 0; i < select.Operands.Count; i++) { var outExpr = select.Operands[i]; if (outExpr.Type == typeof(bool) && !(outExpr is ColumnExpression)) { var wrappedExpr = new SqlFunctionExpression(SqlFunctionType.Iif, typeof(int), outExpr, ExpressionMaker.Const1Int, ExpressionMaker.Const0Int); select.Operands[i] = wrappedExpr; } } return(select); }
public static ModelBuilder UseCustomDbFunctions(this ModelBuilder builder) { var jsonvalueMethodInfo = typeof(Json) .GetRuntimeMethod( nameof(Json.Value), new[] { typeof(string), typeof(string) } ); builder .HasDbFunction(jsonvalueMethodInfo) .HasTranslation(args => SqlFunctionExpression.Create("JSON_VALUE", args, typeof(string), null /* guess */ ) ); var methodInfo = typeof(AnswersToTheUniverse) .GetRuntimeMethod(nameof(AnswersToTheUniverse.What), new Type[0]); builder.HasDbFunction(methodInfo) .HasTranslation(args => SqlFunctionExpression.Create( builder.Model.GetDefaultSchema(), "FortyTwo", args, typeof(int), null /* guess */ )); return(builder); }
private Expression CheckSelectOutputColumn(Expression outCol, SelectExpression select) { // 1. check precision of decimal column // Oracle - old well known bug: InvalidCastException retrieving a high precision decimal // ex: 'Select 1.0/3', blows up when trying read: value= reader[0] // CLR decimal precision is 28 while OracleDecimal is 38, so it just blows up // Workaround - round output values if (outCol.Type == typeof(decimal)) { var colExpr = outCol as ColumnExpression; if (colExpr != null && colExpr.ColumnInfo.Member.Precision <= 27) { return(outCol); // no need to wrap } var roundExpr = new SqlFunctionExpression(SqlFunctionType.Round, typeof(decimal), outCol, Expression.Constant(27)); return(roundExpr); } // 2. Oracle does not allow bool value as output, so 'SELECT (1 > 0)' would fail. // we need to convert it to 1/0 if (outCol.Type == typeof(bool) && !(outCol is ColumnExpression)) { // bools are expressed numeric(1) var convExpr = new SqlFunctionExpression(SqlFunctionType.ConvertBoolToBit, typeof(decimal), outCol); return(convExpr); } return(outCol); }
public void Transform_WithTwoArgument_TypeString() { var method = typeof(string).GetMethod("IndexOf", new[] { typeof(string), typeof(int) }); var objectExpression = Expression.Constant("Test"); var argument1 = Expression.Constant("es"); var argument2 = Expression.Constant(2); var expression = Expression.Call(objectExpression, method, argument1, argument2); var transformer = new IndexOfMethodCallTransformer(); var result = transformer.Transform(expression); var startIndexExpression = Expression.Add(argument2, new SqlLiteralExpression(1)); var lenArgExpression = new SqlLengthExpression(argument1); var leftTestPredicate = Expression.Equal(lenArgExpression, new SqlLiteralExpression(0)); var lenObjectExpression = new SqlLengthExpression(objectExpression); var rightTestpredicate = Expression.LessThanOrEqual(startIndexExpression, lenObjectExpression); var testPredicate = Expression.AndAlso(leftTestPredicate, rightTestpredicate); var charIndexExpression = new SqlFunctionExpression( expression.Type, "CHARINDEX", argument1, objectExpression, startIndexExpression); var elseValue = Expression.Subtract(charIndexExpression, new SqlLiteralExpression(1)); var expectedResult = Expression.Condition(testPredicate, argument2, elseValue); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result); }
public virtual Expression Translate(MethodCallExpression methodCallExpression) { ThrowIf.Argument.IsNull(methodCallExpression, nameof(methodCallExpression)); if (ReferenceEquals(methodCallExpression.Method, _methodInfo)) { var argument = methodCallExpression.Arguments.Count == 1 ? (methodCallExpression.Arguments[0] as ConstantExpression)?.Value as string : null; var sqlArguments = new List <Expression>(); sqlArguments.Add(ConstantExpression.Constant("%")); if (argument != null) { sqlArguments.Add(Expression.Constant(argument)); } else { sqlArguments.Add(methodCallExpression.Arguments[0]); } sqlArguments.Add(ConstantExpression.Constant("%")); var concatFunctionExpression = new SqlFunctionExpression("concat", methodCallExpression.Type, sqlArguments); return(new LikeExpression( methodCallExpression.Object, concatFunctionExpression)); } return(null); }
public virtual SqlFunctionExpression Coalesce(SqlExpression left, SqlExpression right, RelationalTypeMapping typeMapping = null) { Check.NotNull(left, nameof(left)); Check.NotNull(right, nameof(right)); var resultType = right.Type; var inferredTypeMapping = typeMapping ?? ExpressionExtensions.InferTypeMapping(left, right) ?? _typeMappingSource.FindMapping(resultType); var typeMappedArguments = new List<SqlExpression>() { ApplyTypeMapping(left, inferredTypeMapping), ApplyTypeMapping(right, inferredTypeMapping) }; return SqlFunctionExpression.Create( "COALESCE", typeMappedArguments, nullResultAllowed: true, // COALESCE is handled separately since it's only nullable if *both* arguments are null argumentsPropagateNullability: new[] { false, false }, resultType, inferredTypeMapping); }
private static Expression HandleAverage(HandlerContext handlerContext) { if (!handlerContext.QueryModelVisitor.RequiresClientProjection && handlerContext.SelectExpression.Projection.Count == 1) { var expression = handlerContext.SelectExpression.Projection.First(); if (!(expression.RemoveConvert() is SelectExpression)) { var inputType = expression.Type; var outputType = expression.Type; var nonNullableInputType = inputType.UnwrapNullableType(); if (nonNullableInputType == typeof(int) || nonNullableInputType == typeof(long)) { outputType = inputType.IsNullableType() ? typeof(double?) : typeof(double); } expression = new ExplicitCastExpression(expression, outputType); var averageExpression = new SqlFunctionExpression("AVG", expression.Type, new [] { expression }); handlerContext.SelectExpression.SetProjectionExpression(averageExpression); return((Expression)_transformClientExpressionMethodInfo .MakeGenericMethod(averageExpression.Type) .Invoke(null, new object [] { handlerContext })); } } return(handlerContext.EvalOnClient()); }
protected override void OnModelCreating(ModelBuilder modelBuilder) { base.OnModelCreating(modelBuilder); var isDateMethodInfo = typeof(UDFSqlContext).GetMethod(nameof(IsDateStatic)); modelBuilder.HasDbFunction(isDateMethodInfo) .HasTranslation(args => SqlFunctionExpression.Create((string)null, "IsDate", args, isDateMethodInfo.ReturnType, null)); var isDateMethodInfo2 = typeof(UDFSqlContext).GetMethod(nameof(IsDateInstance)); modelBuilder.HasDbFunction(isDateMethodInfo2) .HasTranslation(args => SqlFunctionExpression.Create((string)null, "IsDate", args, isDateMethodInfo2.ReturnType, null)); var methodInfo = typeof(UDFSqlContext).GetMethod(nameof(MyCustomLengthStatic)); modelBuilder.HasDbFunction(methodInfo) .HasTranslation(args => SqlFunctionExpression.Create("char_length", args, methodInfo.ReturnType, null)); var methodInfo2 = typeof(UDFSqlContext).GetMethod(nameof(MyCustomLengthInstance)); modelBuilder.HasDbFunction(methodInfo2) .HasTranslation(args => SqlFunctionExpression.Create("char_length", args, methodInfo2.ReturnType, null)); modelBuilder.HasDbFunction(typeof(UDFSqlContext).GetMethod(nameof(GetCustomerWithMostOrdersAfterDateStatic))) .HasName("GetCustWithMostOrdersAfterDate"); modelBuilder.HasDbFunction(typeof(UDFSqlContext).GetMethod(nameof(GetCustomerWithMostOrdersAfterDateInstance))) .HasName("GetCustWithMostOrdersAfterDate"); modelBuilder.HasDbFunction(typeof(UDFSqlContext).GetMethod(nameof(IdentityString))) .HasSchema(null); }
public void Transform_AddDays() { var value = new CustomExpression(typeof(double)); var methodInfo = MemberInfoFromExpressionUtility.GetMethod(() => DateTime.Now.AddDays(0.0)); var expression = Expression.Call(_dateTimeInstance, methodInfo, value); var result = _transformer.Transform(expression); var expectedResult = new SqlFunctionExpression( typeof(DateTime), "DATEADD", new SqlCustomTextExpression("millisecond", typeof(string)), Expression.Modulo( new SqlConvertExpression(typeof(long), Expression.Multiply(value, new SqlLiteralExpression(86400000.0))), new SqlLiteralExpression(86400000L)), new SqlFunctionExpression ( typeof(DateTime), "DATEADD", new SqlCustomTextExpression("day", typeof(string)), Expression.Divide( new SqlConvertExpression(typeof(long), Expression.Multiply(value, new SqlLiteralExpression(86400000.0))), new SqlLiteralExpression(86400000L)), _dateTimeInstance)); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result); }
//public DbSet<DbUnit> Units { get; set; } //public DbSet<DbRefinery> Refineries { get; set; } //public DbSet<DbUpgrade> Upgrades { get; set; } /* * protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) * { * if (String.IsNullOrEmpty(DSdata.ServerConfig.DBConnectionString)) * throw new NotSupportedException(); * * optionsBuilder * //.UseSqlServer(sc2dsstatslib.Config.DBConnectionString) * .UseMySql(DSdata.ServerConfig.DBConnectionString, mySqlOptions => mySqlOptions * .ServerVersion(new ServerVersion(new Version(5, 7, 29), ServerType.MySql))) * //.ServerVersion(new ServerVersion(new Version(8, 0, 17), ServerType.MySql))) * //.UseLoggerFactory(_loggerFactory) * ; * } */ protected override void OnModelCreating(ModelBuilder modelBuilder) { base.OnModelCreating(modelBuilder); modelBuilder .HasDbFunction(typeof(DBFunctions).GetMethod(nameof(DBFunctions.GetOpp))) .HasTranslation(args => SqlFunctionExpression.Create("GetOpp", args, typeof(int), null)); modelBuilder .HasDbFunction(typeof(DBFunctions).GetMethod(nameof(DBFunctions.GetPl))) .HasTranslation(args => SqlFunctionExpression.Create("GetPl", args, typeof(int), null)); modelBuilder.Entity <DSReplay>(entity => { entity.HasKey(e => e.ID); entity.Property(b => b.HASH) .HasMaxLength(32) .IsFixedLength(); entity.HasIndex(b => b.HASH); // .IsUnique(); entity.HasIndex(b => b.REPLAY); }); modelBuilder.Entity <DbMiddle>(entity => { entity.HasKey(e => e.ID); entity.HasOne(p => p.Replay) .WithMany(d => d.Middle); }); modelBuilder.Entity <DSPlayer>(entity => { entity.HasKey(e => e.ID); entity.Property(p => p.NAME) .HasMaxLength(64); entity.Property(p => p.RACE) .HasMaxLength(64); entity.Property(p => p.OPPRACE) .HasMaxLength(64); entity.HasOne(d => d.DSReplay) .WithMany(p => p.DSPlayer); entity.HasIndex(b => b.RACE); entity.HasIndex(p => new { p.RACE, p.OPPRACE }); }); modelBuilder.Entity <DbBreakpoint>(entity => { entity.HasKey(p => p.ID); entity.HasOne(p => p.Player) .WithMany(d => d.Breakpoints); }); modelBuilder.Entity <DSUnit>(entity => { entity.HasKey(k => k.ID); entity.HasOne(p => p.DSPlayer) .WithMany(d => d.DSUnit); }); }
public override Expression VisitSqlFunction(SqlFunctionExpression sqlFunctionExpression) { if (sqlFunctionExpression.FunctionName.StartsWith("@@", StringComparison.Ordinal)) { Sql.Append(sqlFunctionExpression.FunctionName); return(sqlFunctionExpression); } return(base.VisitSqlFunction(sqlFunctionExpression)); }
public void VisitSqlFunctionExpression() { var sqlFunctionExpression = new SqlFunctionExpression(typeof(int), "LENFUNC", new SqlLiteralExpression("test"), new SqlLiteralExpression(1)); SqlGeneratingExpressionVisitor.GenerateSql( sqlFunctionExpression, _commandBuilder, _stageMock); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("LENFUNC('test', 1)")); }
public override Expression VisitSqlFunction(SqlFunctionExpression sqlFunctionExpression) { if (sqlFunctionExpression.FunctionName.StartsWith("@@")) { Sql.Append(sqlFunctionExpression.FunctionName); return(sqlFunctionExpression); } return(base.VisitSqlFunction(sqlFunctionExpression)); }
/// <inheritdoc /> public override Expression VisitSqlFunction(SqlFunctionExpression sqlFunctionExpression) { switch (sqlFunctionExpression.FunctionName) { case "CAST": { Sql.Append(sqlFunctionExpression.FunctionName); Sql.Append("("); Visit(sqlFunctionExpression.Arguments[0]); Sql.Append(" AS "); Visit(sqlFunctionExpression.Arguments[1]); Sql.Append(")"); return(sqlFunctionExpression); } case "EXTRACT": { Sql.Append(sqlFunctionExpression.FunctionName); Sql.Append("("); Visit(sqlFunctionExpression.Arguments[0]); Sql.Append(" FROM CAST("); Visit(sqlFunctionExpression.Arguments[1]); Sql.Append(" AS TIMESTAMP) AT TIME ZONE '+0')"); return(sqlFunctionExpression); } case "LN": case "LOG": case "LOG10": //Since spanner does not attempt any short circuit eval, //we make these methods return NaN instead of throw //Otherwise, where clauses such as WHERE x > 0 AND LN(x) < [foo] //will throws because the protection of "x > 0" does not stop LN(0) //from being evaluated. Sql.Append("IF("); Visit(sqlFunctionExpression.Arguments[0]); Sql.Append("<=0, CAST('NaN' AS FLOAT64), "); base.VisitSqlFunction(sqlFunctionExpression); Sql.Append(")"); return(sqlFunctionExpression); } return(base.VisitSqlFunction(sqlFunctionExpression)); }
/// <summary> /// SQL函数表达式。 /// </summary> /// <param name="sqlFunctionExpression">表达式实例。</param> /// <returns>返回访问后的表达式实例对象。</returns> public virtual Expression VisitSqlFunction(SqlFunctionExpression sqlFunctionExpression) { _builder.Append(sqlFunctionExpression.FunctionName); _builder.Append("("); VisitJoin(sqlFunctionExpression.Arguments.ToList()); _builder.Append(")"); return(sqlFunctionExpression); }
public virtual Expression VisitSqlFunctionExpression(SqlFunctionExpression expression) { ArgumentUtility.CheckNotNull("expression", expression); _commandBuilder.Append(expression.SqlFunctioName); _commandBuilder.Append("("); _commandBuilder.AppendSeparated(", ", expression.Args, (cb, exp) => VisitExpression(exp)); _commandBuilder.Append(")"); return(expression); }
protected override void OnModelCreating(ModelBuilder modelBuilder) { foreach (var relacao in modelBuilder.Model.GetEntityTypes().SelectMany(ent => ent.GetForeignKeys())) { relacao.DeleteBehavior = DeleteBehavior.Restrict; } modelBuilder.HasDbFunction(typeof(Context).GetMethod(nameof(SoundsLike))) .HasTranslation(args => SqlFunctionExpression.Create("SOUNDEX", args, typeof(string), null)); }
protected internal virtual Expression VisitSqlFunction(SqlFunctionExpression sqlFunction) { Expression?obj = Visit(sqlFunction.Object); ReadOnlyCollection <Expression> args = Visit(sqlFunction.Arguments); if (args != sqlFunction.Arguments || obj != sqlFunction.Object) { return(new SqlFunctionExpression(sqlFunction.Type, obj, sqlFunction.SqlFunction, args)); } return(sqlFunction); }
/// <summary> /// Translates a SpecialExpression to standard Expression equivalent /// </summary> /// <param name="sqlFunction"></param> /// <returns></returns> protected virtual Expression Translate(SqlFunctionExpression sqlFunction) { var operands = sqlFunction.Operands.ToList(); switch (sqlFunction.FunctionType) // SETuse { case SqlFunctionType.IsNull: return(TranslateIsNull(operands)); case SqlFunctionType.IsNotNull: return(TranslateIsNotNull(operands)); case SqlFunctionType.Concat: return(sqlFunction); case SqlFunctionType.StringLength: return(TranslateStringLength(operands)); case SqlFunctionType.ToUpper: return(GetStandardCallInvoke("ToUpper", operands)); case SqlFunctionType.ToLower: return(GetStandardCallInvoke("ToLower", operands)); case SqlFunctionType.StringInsert: return(GetStandardCallInvoke("Insert", operands)); case SqlFunctionType.Substring: case SqlFunctionType.Trim: case SqlFunctionType.LTrim: case SqlFunctionType.RTrim: case SqlFunctionType.Replace: case SqlFunctionType.Remove: case SqlFunctionType.IndexOf: case SqlFunctionType.Year: case SqlFunctionType.Month: case SqlFunctionType.Day: case SqlFunctionType.Hour: case SqlFunctionType.Minute: case SqlFunctionType.Millisecond: case SqlFunctionType.Date: return(GetStandardCallInvoke(sqlFunction.FunctionType.ToString(), operands)); case SqlFunctionType.Now: return(GetDateTimeNowCall(operands)); case SqlFunctionType.DateDiffInMilliseconds: return(GetCallDateDiffInMilliseconds(operands)); default: Util.Throw("S0078: Implement translator for {0}", sqlFunction.FunctionType); return(null); } }
public static SqlFunctionExpression GetFunctionCriteria(MethodCallExpression call, ICriterion criterion, SqlFunctionExpression rightFunction) { System.Type[] paramTypes = null; object[] paramValues = GetMethodParameterValues(call, out paramTypes); int propertyPosition = 0; string methodName = QueryUtil.GetMethodName(call, out propertyPosition); return(new SqlFunctionExpression(methodName, call.Method.ReturnType, paramValues, paramTypes, criterion, propertyPosition, rightFunction)); }
protected virtual Expression VisitSqlFunction(SqlFunctionExpression sqlFunction) { Expression obj = Visit(sqlFunction.Object); ReadOnlyCollection<Expression> args = sqlFunction.Arguments.NewIfChange(a => Visit(a)); if (args != sqlFunction.Arguments || obj != sqlFunction.Object) return new SqlFunctionExpression(sqlFunction.Type, obj, sqlFunction.SqlFunction, args); return sqlFunction; }
protected override Expression VisitSqlFunction(SqlFunctionExpression sqlFunction) { if (sqlFunction.Object != null) { Visit(sqlFunction.Object); sb.Append("."); } sb.Append(sqlFunction.SqlFunction); sb.Append("("); for (int i = 0, n = sqlFunction.Arguments.Count; i < n; i++) { Expression exp = sqlFunction.Arguments[i]; if (i > 0) sb.Append(", "); this.Visit(exp); } sb.Append(")"); return sqlFunction; }
protected override Expression VisitSqlFunction(SqlFunctionExpression sqlFunction) { Expression obj = MakeSqlValue(Visit(sqlFunction.Object)); ReadOnlyCollection<Expression> args = sqlFunction.Arguments.NewIfChange(a => MakeSqlValue(Visit(a))); if (args != sqlFunction.Arguments || obj != sqlFunction.Object) return new SqlFunctionExpression(sqlFunction.Type, obj, sqlFunction.SqlFunction, args); return sqlFunction; }