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 SqlFunctionExpression(SqlFunctionType functionType, Type type, bool ignoreCase, params Expression[] operands)
: base(SqlExpressionType.SqlFunction, type, operands)
{
this.FunctionType = functionType;
this.ForceIgnoreCase = ignoreCase;
}
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;
}
}
public SqlFunctionExpression(SqlFunctionType functionType, Type type, params Expression[] operands)
: this(functionType, type, true, operands)
{
}
