public override Type GetSqlFunctionResultType(SqlFunctionType functionType, Type[] operandTypes) { switch(functionType) { case SqlFunctionType.Count: return typeof(long); } return base.GetSqlFunctionResultType(functionType, operandTypes); }
public override string Translate(SqlFunctionType type) { switch (type) { case SqlFunctionType.Truncate: case SqlFunctionType.DateTimeTruncate: return("TRUNC"); case SqlFunctionType.IntervalNegate: return("-1*"); case SqlFunctionType.Substring: return("SUBSTR"); case SqlFunctionType.Log: return("LN"); case SqlFunctionType.Log10: return("LOG"); case SqlFunctionType.Ceiling: return("CEIL"); case SqlFunctionType.CurrentDateTimeOffset: return("CURRENT_TIMESTAMP"); default: return(base.Translate(type)); } }
public override string Translate(SqlFunctionType functionType) { switch (functionType) { case SqlFunctionType.IntervalAbs: return("ABS"); case SqlFunctionType.IntervalNegate: return("-"); case SqlFunctionType.CurrentDate: return("GETDATE"); case SqlFunctionType.CharLength: return("LEN"); case SqlFunctionType.BinaryLength: return("DATALENGTH"); case SqlFunctionType.Position: return("CHARINDEX"); case SqlFunctionType.Atan2: return("ATN2"); case SqlFunctionType.LastAutoGeneratedId: return("SCOPE_IDENTITY"); } return(base.Translate(functionType)); }
public virtual SqlTemplate GetTemplate(SqlFunctionType functionType) { if (this.SqlFunctionTemplates.TryGetValue(functionType, out SqlTemplate template)) { return(template); } return(null); }
public virtual int GetPrecedence(SqlFunctionType type) { if (SqlFunctionPrecedences.TryGetValue(type, out int result)) { return(result); } return(SqlPrecedence.NoPrecedence); }
public override Type GetSqlFunctionResultType(SqlFunctionType functionType, Type[] operandTypes) { switch (functionType) { case SqlFunctionType.Count: return(typeof(long)); } return(base.GetSqlFunctionResultType(functionType, operandTypes)); }
public virtual SqlFunctionExpression CreateSqlFunction(SqlFunctionType functionType, bool ignoreCase, params Expression[] operands) { Type[] opTypes = null; if (operands != null && operands.Length > 0) opTypes = operands.Select(op => op.Type).ToArray(); var outType = _dbModel.LinqSqlProvider.GetSqlFunctionResultType(functionType, opTypes); return new SqlFunctionExpression(functionType, outType, ignoreCase, operands); }
public override string Translate(SqlFunctionType functionType) { switch (functionType) { case SqlFunctionType.CurrentDateTimeOffset: return("SYSDATETIMEOFFSET"); } return(base.Translate(functionType)); }
// Constructors internal SqlFunctionCall(SqlFunctionType functionType, IEnumerable <SqlExpression> arguments) : base(SqlNodeType.FunctionCall) { FunctionType = functionType; Arguments = new Collection <SqlExpression>(); foreach (SqlExpression argument in arguments) { Arguments.Add(argument); } }
public void ResolveHaving <T>(SqlFunctionType type, Expression <Func <T, bool> > expression) { builder.And(); builder.FunctionType = type; builder.PartType = SqlPartType.Having; var node = ResolveQuery((dynamic)expression.Body); builder.BuildWhere(node); }
public virtual SqlFunctionExpression CreateSqlFunction(SqlFunctionType functionType, bool ignoreCase, params Expression[] operands) { Type[] opTypes = null; if (operands != null && operands.Length > 0) { opTypes = operands.Select(op => op.Type).ToArray(); } var outType = _dbModel.Driver.SqlDialect.GetSqlFunctionResultType(functionType, opTypes); return(new SqlFunctionExpression(functionType, outType, ignoreCase, operands)); }
public override void ReplaceWith(SqlExpression expression) { ArgumentValidator.EnsureArgumentNotNull(expression, "expression"); ArgumentValidator.EnsureArgumentIs <SqlFunctionCall>(expression, "expression"); var replacingExpression = (SqlFunctionCall)expression; FunctionType = replacingExpression.FunctionType; Arguments.Clear(); foreach (SqlExpression argument in replacingExpression.Arguments) { Arguments.Add(argument); } }
internal SqlFunctionCall(SqlFunctionType functionType, params SqlExpression[] arguments) : base(SqlNodeType.FunctionCall) { FunctionType = functionType; Arguments = new Collection <SqlExpression>(); if (arguments != null) { foreach (SqlExpression argument in arguments) { Arguments.Add(argument); } } }
/// <inheritdoc/> public override string Translate(SqlFunctionType type) { switch (type) { case SqlFunctionType.CharLength: return("CHAR_LENGTH"); case SqlFunctionType.BinaryLength: return("OCTET_LENGTH"); case SqlFunctionType.Truncate: return("TRUNC"); case SqlFunctionType.IntervalNegate: return("-"); case SqlFunctionType.Log: return("LN"); case SqlFunctionType.Log10: return("LOG10"); case SqlFunctionType.Ceiling: return("CEIL"); case SqlFunctionType.PadLeft: return("LPAD"); case SqlFunctionType.PadRight: return("RPAD"); case SqlFunctionType.Concat: return("||"); case SqlFunctionType.SystemUser: case SqlFunctionType.SessionUser: return(base.Translate(SqlFunctionType.CurrentUser)); case SqlFunctionType.Degrees: case SqlFunctionType.Radians: case SqlFunctionType.Square: throw SqlHelper.NotSupported(type.ToString()); case SqlFunctionType.IntervalAbs: return(Translate(SqlFunctionType.Abs)); default: return(base.Translate(type)); } }
public override string Translate(SqlFunctionType type) { switch (type) { //date case SqlFunctionType.CurrentDate: return("date_trunc('day', clock_timestamp())"); case SqlFunctionType.CurrentTimeStamp: return("clock_timestamp()"); default: return(base.Translate(type)); } }
public void ResolveHaving <T, TKey>(SqlFunctionType type, Expression <Func <T, TKey> > expression, ExpressionType expType, object value) { builder.FunctionType = type; builder.PartType = SqlPartType.Having; var member = ExpressionHelper.GetMemberExpression(expression.Body); if (member != null) { OperationNode node = new OperationNode(); node.Left = new MemberNode(member); node.Right = new ValueNode(value); node.Operator = expType; builder.BuildWhere(node); } }
/// <inheritdoc/> public override string Translate(SqlFunctionType functionType) { switch (functionType) { case SqlFunctionType.Acos: case SqlFunctionType.Asin: case SqlFunctionType.Atan: case SqlFunctionType.Atan2: case SqlFunctionType.Sin: case SqlFunctionType.SessionUser: case SqlFunctionType.Sqrt: case SqlFunctionType.Square: case SqlFunctionType.Tan: case SqlFunctionType.Position: case SqlFunctionType.Power: throw SqlHelper.NotSupported(functionType.ToString()); case SqlFunctionType.Concat: return("||"); case SqlFunctionType.IntervalAbs: return("ABS"); case SqlFunctionType.Substring: return("SUBSTR"); case SqlFunctionType.IntervalNegate: return("-"); case SqlFunctionType.CurrentDate: return("DATE()"); case SqlFunctionType.BinaryLength: return("LENGTH"); case SqlFunctionType.LastAutoGeneratedId: return("LAST_INSERT_ROWID()"); case SqlFunctionType.DateTimeAddMonths: return("DATE"); case SqlFunctionType.DateTimeConstruct: return("DATETIME"); } return(base.Translate(functionType)); }
protected override SqlStatement GetLiteralDateTimePart(SqlStatement dateExpression, SqlFunctionType operationType) { switch (operationType) { case SqlFunctionType.Date: return SqlStatement.Format("DATE({0})", dateExpression); case SqlFunctionType.Time: return SqlStatement.Format("DATE_PART('time', {0})", dateExpression); case SqlFunctionType.Week: return SqlStatement.Format("EXTRACT(WEEK FROM {0})", dateExpression); case SqlFunctionType.Year: return SqlStatement.Format("EXTRACT(YEAR FROM {0})", dateExpression); case SqlFunctionType.Month: return SqlStatement.Format("EXTRACT(MONTH FROM {0})", dateExpression); case SqlFunctionType.Day: return SqlStatement.Format("EXTRACT(DAY FROM {0})", dateExpression); default: Util.Throw("SQL function {0} not supported.", operationType); return null; } }
public virtual SqlStatement GetSqlFunction(SqlFunctionType functionType, bool forceIgnoreCase, IList<SqlStatement> parameters) { var pLast = parameters.LastOrDefault(); switch (functionType) // { case SqlFunctionType.IsNull: return GetLiteralIsNull(parameters[0]); case SqlFunctionType.IsNotNull: return GetLiteralIsNotNull(parameters[0]); case SqlFunctionType.EqualNullables: return GetEqualNullables(parameters[0], parameters[1]); case SqlFunctionType.Concat: return GetLiteralStringConcat(parameters[0], parameters[1]); case SqlFunctionType.Count: return GetLiteralCount(parameters[0]); case SqlFunctionType.Exists: return GetLiteralExists(parameters[0]); case SqlFunctionType.Like: return GetLiteralLike(parameters[0], parameters[1], forceIgnoreCase); // RI: changed index to 1 (from 0) for Min, Max, Avg, Sum case SqlFunctionType.Min: return GetLiteralMin(pLast); case SqlFunctionType.Max: return GetLiteralMax(pLast); case SqlFunctionType.Sum: return GetLiteralSum(pLast); case SqlFunctionType.Average: return GetLiteralAverage(pLast); case SqlFunctionType.StringLength: return GetLiteralStringLength(parameters[0]); case SqlFunctionType.ToUpper: return GetLiteralStringToUpper(parameters[0]); case SqlFunctionType.ToLower: return GetLiteralStringToLower(parameters[0]); case SqlFunctionType.In: return GetLiteralIn(parameters[0], parameters[1]); case SqlFunctionType.InArray: return GetLiteralInArray(parameters[0], parameters[1]); case SqlFunctionType.StringEqual: return GetLiteralStringEqual(parameters[0], parameters[1], forceIgnoreCase); case SqlFunctionType.Substring: if (parameters.Count > 2) return GetLiteralSubString(parameters[0], parameters[1], parameters[2]); else return GetLiteralSubString(parameters[0], parameters[1]); case SqlFunctionType.Trim: case SqlFunctionType.LTrim: case SqlFunctionType.RTrim: return GetLiteralTrim(parameters[0]); case SqlFunctionType.StringInsert: return GetLiteralStringInsert(parameters[0], parameters[1], parameters[2]); case SqlFunctionType.Replace: return GetLiteralStringReplace(parameters[0], parameters[1], parameters[2]); case SqlFunctionType.Remove: if (parameters.Count > 2) return GetLiteralStringRemove(parameters[0], parameters[1], parameters[2]); return GetLiteralStringRemove(parameters[0], parameters[1]); case SqlFunctionType.IndexOf: if (parameters.Count == 2) return GetLiteralStringIndexOf(parameters[0], parameters[1]); else if (parameters.Count == 3) return GetLiteralStringIndexOf(parameters[0], parameters[1], parameters[2]); else if (parameters.Count == 4) return GetLiteralStringIndexOf(parameters[0], parameters[1], parameters[2], parameters[3]); break; case SqlFunctionType.Year: case SqlFunctionType.Month: case SqlFunctionType.Day: case SqlFunctionType.Hour: case SqlFunctionType.Minute: case SqlFunctionType.Second: case SqlFunctionType.Millisecond: case SqlFunctionType.Date: case SqlFunctionType.Time: case SqlFunctionType.Week: return GetLiteralDateTimePart(parameters[0], functionType); case SqlFunctionType.DateDiffInMilliseconds: return GetLiteralDateDiff(parameters[0], parameters[1]); case SqlFunctionType.Abs: return GetLiteralMathAbs(parameters[0]); case SqlFunctionType.Exp: return GetLiteralMathExp(parameters[0]); case SqlFunctionType.Floor: return GetLiteralMathFloor(parameters[0]); case SqlFunctionType.Ln: return GetLiteralMathLn(parameters[0]); case SqlFunctionType.Log: if (parameters.Count == 1) return GetLiteralMathLog(parameters[0]); else return GetLiteralMathLog(parameters[0], parameters[1]); case SqlFunctionType.Pow: return GetLiteralMathPow(parameters[0], parameters[1]); case SqlFunctionType.Round: return GetLiteralMathRound(parameters[0]); case SqlFunctionType.Sign: return GetLiteralMathSign(parameters[0]); case SqlFunctionType.Sqrt: return GetLiteralMathSqrt(parameters[0]); case SqlFunctionType.AndBitwise: return GetLiteralAndBitwise(parameters[0], parameters[1]); case SqlFunctionType.OrBitwise: return GetLiteralOrBitwise(parameters[0], parameters[1]); case SqlFunctionType.XorBitwise: return GetLiteralExclusiveOrBitwise(parameters[0], parameters[1]); case SqlFunctionType.ConvertBoolToBit: return GetConvertBoolToBit(parameters[0]); case SqlFunctionType.NewGuid: return GetNewGuid(); }//switch throw new ArgumentException(functionType.ToString()); }
public virtual SqlFunctionExpression CreateSqlFunction(SqlFunctionType functionType, params Expression[] operands) { return CreateSqlFunction(functionType, true, operands); }
public IHaving <T> Having(SqlFunctionType type, Expression <Func <T, bool> > expression) { QueryVisitor.ResolveHaving(type, expression); return(this); }
public IGroupBy <T> SelectFunction <TKey>(SqlFunctionType type, params Expression <Func <T, TKey> >[] expressions) { Builder.FunctionType = type; return(ResolveFieldExpression(SqlPartType.Function, expressions)); }
public virtual SqlFunctionExpression CreateSqlFunction(SqlFunctionType functionType, params Expression[] operands) { return(CreateSqlFunction(functionType, true, operands)); }
public virtual Type GetSqlFunctionResultType(SqlFunctionType functionType, Type[] operandTypes) { Type defaultType = null; //RI: changed to use op[1] (from 0) here - this is selector if (operandTypes != null && operandTypes.Length > 0) { defaultType = operandTypes[operandTypes.Length - 1]; } switch (functionType) { case SqlFunctionType.IsNull: case SqlFunctionType.IsNotNull: case SqlFunctionType.EqualNullables: case SqlFunctionType.StringEqual: return(typeof(bool)); case SqlFunctionType.Concat: return(typeof(string)); case SqlFunctionType.Exists: return(typeof(bool)); case SqlFunctionType.Like: return(typeof(bool)); case SqlFunctionType.StringLength: return(typeof(int)); case SqlFunctionType.ToUpper: case SqlFunctionType.ToLower: return(typeof(string)); case SqlFunctionType.In: case SqlFunctionType.InArray: return(typeof(bool)); case SqlFunctionType.Substring: return(defaultType); case SqlFunctionType.Trim: case SqlFunctionType.LTrim: case SqlFunctionType.RTrim: return(typeof(string)); case SqlFunctionType.Year: case SqlFunctionType.Month: case SqlFunctionType.Day: case SqlFunctionType.Hour: case SqlFunctionType.Second: case SqlFunctionType.Minute: case SqlFunctionType.Millisecond: case SqlFunctionType.Week: return(typeof(int)); case SqlFunctionType.Now: case SqlFunctionType.Date: return(typeof(DateTime)); case SqlFunctionType.Time: return(typeof(TimeSpan)); case SqlFunctionType.DateDiffInMilliseconds: return(typeof(long)); case SqlFunctionType.Abs: case SqlFunctionType.Exp: case SqlFunctionType.Floor: case SqlFunctionType.Ln: case SqlFunctionType.Log: case SqlFunctionType.Round: case SqlFunctionType.Sign: case SqlFunctionType.Sqrt: return(defaultType); case SqlFunctionType.AndBitwise: case SqlFunctionType.OrBitwise: case SqlFunctionType.XorBitwise: return(defaultType); case SqlFunctionType.ConvertBoolToBit: return(typeof(bool)); default: Util.Throw("Unknown SqlFunctionType value {0}", functionType); return(null); } }
public static FunctionSqlExpression Function(SqlFunctionType type, params SqlExpression[] parameters) { return(new FunctionSqlExpression(type, parameters)); }
public SqlFunctionExpression(SqlFunctionType type, params SqlExpression[] arguments) { Type = type; Arguments = arguments; }
protected override SqlStatement GetLiteralDateTimePart(SqlStatement dateExpression, SqlFunctionType operationType) { switch (operationType) { case SqlFunctionType.Week: return(SqlStatement.Format("DATEPART(ISOWK,{0})", dateExpression)); case SqlFunctionType.Date: return(SqlStatement.Format("CONVERT(DATE, {0})", dateExpression)); case SqlFunctionType.Time: return(SqlStatement.Format("CONVERT(TIME, {0})", dateExpression)); default: return(SqlStatement.Format("DATEPART({0},{1})", operationType.ToString().ToUpper(), dateExpression)); } }
protected override SqlStatement GetLiteralDateTimePart(SqlStatement dateExpression, SqlFunctionType operationType) { Util.Throw("SQL function {0} not supported.", operationType); return null; }
private object EvaluateMathCallInvoke(SqlFunctionType SpecialNodeType, IList<Expression> operands) { return typeof(Math).GetMethod(SpecialNodeType.ToString(), operands.Skip(1).Select(op => op.Type).ToArray()) .Invoke(null, operands.Skip(1).Select(op => op.Evaluate()).ToArray()); }
public SqlFunctionExpression(SqlFunctionType functionType, Type type, bool ignoreCase, params Expression[] operands) : base(SqlExpressionType.SqlFunction, type, operands) { this.FunctionType = functionType; this.ForceIgnoreCase = ignoreCase; }
private object EvaluateMathCallInvoke(SqlFunctionType SpecialNodeType, IList <Expression> operands) { return(typeof(Math).GetMethod(SpecialNodeType.ToString(), operands.Skip(1).Select(op => op.Type).ToArray()) .Invoke(null, operands.Skip(1).Select(op => op.Evaluate()).ToArray())); }
protected virtual Expression AnalyzeGenericSpecialExpressionType(SqlFunctionType specialType, IList<Expression> parameters, TranslationContext context) { return CreateSqlFunction(specialType, parameters.Select(p => Analyze(p, context)).ToArray()); }
protected override SqlStatement GetLiteralDateTimePart(SqlStatement dateExpression, SqlFunctionType operationType) { switch (operationType) { case SqlFunctionType.Date: return(SqlStatement.Format("DATE({0})", dateExpression)); case SqlFunctionType.Week: return(SqlStatement.Format("WEEK({0})", dateExpression)); case SqlFunctionType.Year: return(SqlStatement.Format("YEAR({0})", dateExpression)); case SqlFunctionType.Month: return(SqlStatement.Format("MONTH({0})", dateExpression)); case SqlFunctionType.Day: return(SqlStatement.Format("Day({0})", dateExpression)); // case SqlFunctionType.Time: // TIME() returns string, so this does not work // return SqlStatement.Format("TIME({0})", dateExpression); default: Util.Throw("SQL function {0} not supported.", operationType); return(null); } }
protected override SqlStatement GetLiteralDateTimePart(SqlStatement dateExpression, SqlFunctionType operationType) { switch (operationType) { case SqlFunctionType.Week: return SqlStatement.Format("DATEPART(ISOWK,{0})", dateExpression); case SqlFunctionType.Date: return SqlStatement.Format("CONVERT(DATE, {0})", dateExpression); case SqlFunctionType.Time: return SqlStatement.Format("CONVERT(TIME, {0})", dateExpression); default: return SqlStatement.Format("DATEPART({0},{1})", operationType.ToString().ToUpper(), dateExpression); } }
public IHaving <T> Having <TKey>(SqlFunctionType type, Expression <Func <T, TKey> > expression, ExpressionType expType, object value) { QueryVisitor.ResolveHaving(type, expression, expType, value); return(this); }
public override string Translate(SqlFunctionType type) { switch (type) { case SqlFunctionType.SystemUser: return(string.Empty); case SqlFunctionType.User: case SqlFunctionType.CurrentUser: return("current_user"); case SqlFunctionType.SessionUser: return("session_user"); case SqlFunctionType.NullIf: return("nullif"); case SqlFunctionType.Coalesce: return("coalesce"); case SqlFunctionType.BinaryLength: return("length"); //datetime/timespan case SqlFunctionType.CurrentDate: return("date_trunc('day', current_timestamp)"); case SqlFunctionType.CurrentTimeStamp: return("current_timestamp"); case SqlFunctionType.IntervalNegate: return("-"); //string case SqlFunctionType.CharLength: return("char_length"); case SqlFunctionType.Lower: return("lower"); case SqlFunctionType.Position: return("position"); case SqlFunctionType.Substring: return("substring"); case SqlFunctionType.Upper: return("upper"); case SqlFunctionType.Concat: return("textcat"); //math case SqlFunctionType.Abs: return("abs"); case SqlFunctionType.Acos: return("acos"); case SqlFunctionType.Asin: return("asin"); case SqlFunctionType.Atan: return("atan"); case SqlFunctionType.Atan2: return("atan2"); case SqlFunctionType.Ceiling: return("ceil"); case SqlFunctionType.Cos: return("cos"); case SqlFunctionType.Cot: return("cot"); case SqlFunctionType.Degrees: return("degrees"); case SqlFunctionType.Exp: return("exp"); case SqlFunctionType.Floor: return("floor"); case SqlFunctionType.Log: return("ln"); case SqlFunctionType.Log10: return("log"); case SqlFunctionType.Pi: return("pi"); case SqlFunctionType.Power: return("power"); case SqlFunctionType.Radians: return("radians"); case SqlFunctionType.Rand: return("random"); case SqlFunctionType.Round: return("round"); case SqlFunctionType.Truncate: return("trunc"); case SqlFunctionType.Sign: return("sign"); case SqlFunctionType.Sqrt: return("sqrt"); case SqlFunctionType.Tan: return("tan"); default: return(base.Translate(type)); } }
/// <inheritdoc/> public override string Translate(SqlFunctionType type) { switch (type) { case SqlFunctionType.LastAutoGeneratedId: return("LAST_INSERT_ID()"); case SqlFunctionType.SystemUser: return("SYSTEM_USER()"); case SqlFunctionType.User: case SqlFunctionType.CurrentUser: return("CURRENT_USER()"); case SqlFunctionType.SessionUser: return("SESSION_USER()"); case SqlFunctionType.NullIf: return("IFNULL"); case SqlFunctionType.Coalesce: return("COALESCE"); case SqlFunctionType.BinaryLength: return("LENGTH"); //datetime/timespan case SqlFunctionType.DateTimeTruncate: return("DATE"); case SqlFunctionType.CurrentDate: return("CURDATE()"); case SqlFunctionType.CurrentTimeStamp: return("NOW()"); case SqlFunctionType.IntervalNegate: return("-"); case SqlFunctionType.DateTimeAddYears: case SqlFunctionType.DateTimeAddMonths: case SqlFunctionType.DateTimeConstruct: case SqlFunctionType.IntervalToMilliseconds: return(string.Empty); //string case SqlFunctionType.CharLength: return("CHAR_LENGTH"); case SqlFunctionType.Lower: return("LCASE"); case SqlFunctionType.Position: return("LOCATE"); case SqlFunctionType.Substring: return("SUBSTRING"); case SqlFunctionType.Upper: return("UCASE"); case SqlFunctionType.Concat: return("CONCAT()"); //math case SqlFunctionType.Abs: return("ABS"); case SqlFunctionType.Acos: return("ACOS"); case SqlFunctionType.Asin: return("ASIN"); case SqlFunctionType.Atan: return("ATAN"); case SqlFunctionType.Atan2: return("ATAN2"); case SqlFunctionType.Ceiling: return("CEIL"); case SqlFunctionType.Cos: return("COS"); case SqlFunctionType.Cot: return("COT"); case SqlFunctionType.Degrees: return("DEGREES"); case SqlFunctionType.Exp: return("EXP"); case SqlFunctionType.Floor: return("FLOOR"); case SqlFunctionType.Log: return("LN"); case SqlFunctionType.Log10: return("LOG"); case SqlFunctionType.Pi: return("PI"); case SqlFunctionType.Power: return("POWER"); case SqlFunctionType.Radians: return("RADIANS"); case SqlFunctionType.Rand: return("RAND"); case SqlFunctionType.Round: return("ROUND"); case SqlFunctionType.Truncate: return("TRUNCATE"); case SqlFunctionType.Sign: return("SIGN"); case SqlFunctionType.Sqrt: return("SQRT"); case SqlFunctionType.Tan: return("TAN"); default: return(base.Translate(type)); } }
public SqlFunctionExpression(SqlFunctionType functionType, Type type, params Expression[] operands) : this(functionType, type, true, operands) { }
/// <summary> /// Gets the literal date time part. /// </summary> /// <param name="dateExpression">The date expression.</param> /// <param name="operationType">Type of the operation.</param> /// <returns></returns> protected virtual SqlStatement GetLiteralDateTimePart(SqlStatement dateExpression, SqlFunctionType operationType) { return SqlStatement.Format("EXTRACT({0} FROM {1})", operationType.ToString().ToUpper(), dateExpression); }
public virtual Type GetSqlFunctionResultType(SqlFunctionType functionType, Type[] operandTypes) { Type defaultType = null; //RI: changed to use op[1] (from 0) here - this is selector if(operandTypes != null && operandTypes.Length > 0) defaultType = operandTypes[operandTypes.Length - 1]; // TODO: see if this is necessary at all, maybe just return output type switch(functionType) { case SqlFunctionType.IsNull: case SqlFunctionType.IsNotNull: case SqlFunctionType.EqualNullables: case SqlFunctionType.StringEqual: return typeof(bool); case SqlFunctionType.Concat: return typeof(string); case SqlFunctionType.Count: return typeof(int); case SqlFunctionType.Exists: return typeof(bool); case SqlFunctionType.Like: return typeof(bool); case SqlFunctionType.Min: case SqlFunctionType.Max: case SqlFunctionType.Sum: return defaultType; // for such methods, the type is related to the operands type case SqlFunctionType.Average: if(defaultType == typeof(decimal) || defaultType == typeof(float)) return defaultType; return typeof(double); case SqlFunctionType.StringLength: return typeof(int); case SqlFunctionType.ToUpper: case SqlFunctionType.ToLower: return typeof(string); case SqlFunctionType.In: case SqlFunctionType.InArray: return typeof(bool); case SqlFunctionType.Substring: return defaultType; case SqlFunctionType.Trim: case SqlFunctionType.LTrim: case SqlFunctionType.RTrim: return typeof(string); case SqlFunctionType.StringInsert: return typeof(string); case SqlFunctionType.Replace: return typeof(string); case SqlFunctionType.Remove: return typeof(string); case SqlFunctionType.IndexOf: return typeof(int); case SqlFunctionType.Year: case SqlFunctionType.Month: case SqlFunctionType.Day: case SqlFunctionType.Hour: case SqlFunctionType.Second: case SqlFunctionType.Minute: case SqlFunctionType.Millisecond: case SqlFunctionType.Week: return typeof(int); case SqlFunctionType.Now: case SqlFunctionType.Date: return typeof(DateTime); case SqlFunctionType.Time: return typeof(TimeSpan); case SqlFunctionType.DateDiffInMilliseconds: return typeof(long); case SqlFunctionType.Abs: case SqlFunctionType.Exp: case SqlFunctionType.Floor: case SqlFunctionType.Ln: case SqlFunctionType.Log: case SqlFunctionType.Pow: case SqlFunctionType.Round: case SqlFunctionType.Sign: case SqlFunctionType.Sqrt: return defaultType; case SqlFunctionType.AndBitwise: case SqlFunctionType.OrBitwise: case SqlFunctionType.XorBitwise: return defaultType; case SqlFunctionType.ConvertBoolToBit: return typeof(bool); default: Util.Throw("S0058: Unknown SpecialExpressionType value {0}", functionType); return null; } }
protected override SqlStatement GetLiteralDateTimePart(SqlStatement dateExpression, SqlFunctionType operationType) { switch (operationType) { case SqlFunctionType.Date: return SqlStatement.Format("DATE({0})", dateExpression); case SqlFunctionType.Week: return SqlStatement.Format("WEEK({0})", dateExpression); case SqlFunctionType.Year: return SqlStatement.Format("YEAR({0})", dateExpression); case SqlFunctionType.Month: return SqlStatement.Format("MONTH({0})", dateExpression); case SqlFunctionType.Day: return SqlStatement.Format("Day({0})", dateExpression); // case SqlFunctionType.Time: // TIME() returns string, so this does not work // return SqlStatement.Format("TIME({0})", dateExpression); default: Util.Throw("SQL function {0} not supported.", operationType); return null; } }
protected virtual Expression AnalyzeProjectionQuery(SqlFunctionType specialExpressionType, IList<Expression> parameters, TranslationContext context, bool canHaveFilter = true) { if (context.IsExternalInExpressionChain) { var operand0 = Analyze(parameters[0], context); Expression functionOperand = null; Expression projectionOperand; if ( context.CurrentSelect.NextSelectExpression != null || context.CurrentSelect.Operands.Count() > 0 || context.CurrentSelect.Group.Count > 0 ) { // No TableInfo in projection operand0 = new SubSelectExpression(context.CurrentSelect, operand0.Type, "source", null); context.NewParentSelect(); // In the new scope we should not have MaximumDatabaseLoad //context.QueryContext.MaximumDatabaseLoad = false; context.CurrentSelect.Tables.Add(operand0 as TableExpression); } // basically, we have three options for projection methods: // - projection on grouped table (1 operand, a GroupExpression) // - projection on grouped column (2 operands, GroupExpression and ColumnExpression) // - projection on table/column, with optional restriction var groupOperand0 = operand0 as GroupExpression; if (groupOperand0 != null) { if (parameters.Count > 1) projectionOperand = Analyze(parameters[1], groupOperand0.GroupedExpression, context); else projectionOperand = Analyze(groupOperand0.GroupedExpression, context); } else { projectionOperand = operand0; if (parameters.Count > 1) functionOperand = Analyze(parameters[1], operand0, context); int filterIndex = canHaveFilter ? 1 : -1; //special case for Average - its second parameter is NOT filter CheckWhere(projectionOperand, parameters, filterIndex, context); } if (projectionOperand is TableExpression) projectionOperand = RegisterTable((TableExpression)projectionOperand, context); if (groupOperand0 != null) { var childColumns = GetChildColumns(projectionOperand, context); projectionOperand = new GroupExpression(projectionOperand, groupOperand0.KeyExpression, childColumns); } var opList = new List<Expression>(); opList.Add(projectionOperand); if (functionOperand != null) opList.Add(functionOperand); return CreateSqlFunction(specialExpressionType, opList.ToArray()); } else { var subQueryContext = context.NewSelect(); var tableExpression = Analyze(parameters[0], subQueryContext); //RI: new stuff - handling grouping with aggregates //if (IsAggregate(specialExpressionType)) { var grpExpr = tableExpression as GroupExpression; var srcTable = grpExpr == null ? tableExpression : grpExpr.GroupedExpression ; SqlFunctionExpression specialExpr; if (parameters.Count > 1) { var predicate = Analyze(parameters[1], srcTable, subQueryContext); specialExpr = CreateSqlFunction(specialExpressionType, tableExpression, predicate); } else { specialExpr = CreateSqlFunction(specialExpressionType, tableExpression); } // If subQuery context has no tables added, it is not a subquery, it's just an aggregate function over 'main' table var currSelect = subQueryContext.CurrentSelect; if (currSelect.Tables.Count == 0) return specialExpr; //this is a real subquery, so mutate and return the current select from this context currSelect = currSelect.ChangeOperands(new Expression[] { specialExpr }, currSelect.Operands); return currSelect; //} //RI: end my special code } }
protected override SqlStatement GetLiteralDateTimePart(SqlStatement dateExpression, SqlFunctionType operationType) { switch (operationType) { case SqlFunctionType.Date: return(SqlStatement.Format("DATE({0})", dateExpression)); case SqlFunctionType.Time: return(SqlStatement.Format("DATE_PART('time', {0})", dateExpression)); case SqlFunctionType.Week: return(SqlStatement.Format("EXTRACT(WEEK FROM {0})", dateExpression)); case SqlFunctionType.Year: return(SqlStatement.Format("EXTRACT(YEAR FROM {0})", dateExpression)); case SqlFunctionType.Month: return(SqlStatement.Format("EXTRACT(MONTH FROM {0})", dateExpression)); case SqlFunctionType.Day: return(SqlStatement.Format("EXTRACT(DAY FROM {0})", dateExpression)); default: Util.Throw("SQL function {0} not supported.", operationType); return(null); } }
private bool IsAggregate(SqlFunctionType type) { switch(type) { case SqlFunctionType.Min: case SqlFunctionType.Max: case SqlFunctionType.Average: case SqlFunctionType.Count: case SqlFunctionType.Sum: return true; default: return false; } }