internal string Format(ExpressionContext context)
{
if (_operator == ExpressionOperator.None)
{
return this.Reference != null ?
FormatReference(context) : this.Function != null ?
FormatFunction(context) :
FormatValue(context);
}
else if (_operator == ExpressionOperator.NOT || _operator == ExpressionOperator.NEG)
{
var left = FormatExpression(_left, context);
var op = FormatOperator(context);
if (NeedsGrouping(_left))
return string.Format("{0}({1})", op, left);
else
return string.Format("{0} {1}", op, left);
}
else
{
var left = FormatExpression(_left, context);
var right = FormatExpression(_right, context);
var op = FormatOperator(context);
if (NeedsGrouping(_left))
return string.Format("({0}) {1} {2}", left, op, right);
else if (NeedsGrouping(_right))
return string.Format("{0} {1} ({2})", left, op, right);
else
return string.Format("{0} {1} {2}", left, op, right);
}
}
private string FormatReference(ExpressionContext context)
{
var elementNames = new List<string>(this.Reference.Split('.'));
var entityCollection = context.EntityCollection;
var segmentNames = BuildReferencePath(new List<string>(), entityCollection, elementNames, context);
return string.Join("/", segmentNames);
}
private static string FormatExpression(ODataExpression expr, ExpressionContext context)
{
if (ReferenceEquals(expr, null))
{
return "null";
}
else
{
return expr.Format(context);
}
}
private string FormatValue(object value, FormattingStyle formattingStyle, ExpressionContext context)
{
return value == null ? "null"
: value is FilterExpression ? (value as FilterExpression).Format(context)
: value is string ? string.Format("'{0}'", value)
: value is DateTime ? ((DateTime)value).ToIso8601String()
: value is bool ? value.ToString().ToLower()
: (value is long || value is ulong) ? value + (formattingStyle == FormattingStyle.Content ? "L" : string.Empty)
: value is float ? ((float)value).ToString(CultureInfo.InvariantCulture)
: value is double ? ((double)value).ToString(CultureInfo.InvariantCulture)
: value is decimal ? ((decimal)value).ToString(CultureInfo.InvariantCulture)
: value.ToString();
}
private string FormatFunction(ExpressionContext context)
{
FunctionMapping mapping;
if (FunctionMapping.SupportedFunctions.TryGetValue(new ExpressionFunction.FunctionCall(this.Function.FunctionName, this.Function.Arguments.Count()), out mapping))
{
var mappedFunction = mapping.FunctionMapper(this.Function.FunctionName, _functionCaller.Format(context), this.Function.Arguments).Function;
return string.Format("{0}({1})", mappedFunction.FunctionName,
string.Join(",", (IEnumerable<object>)mappedFunction.Arguments.Select(x => FormatExpression(x, context))));
}
else
{
throw new NotSupportedException(string.Format("The function {0} is not supported or called with wrong number of arguments", this.Function.FunctionName));
}
}
private string FormatValue(object value, FormattingStyle formattingStyle, ExpressionContext context)
{
return value == null ? "null"
: value is FilterExpression ? (value as FilterExpression).Format(context)
: value is string ? string.Format("'{0}'", value)
: value is DateTime ? ((DateTime)value).ToODataString(formattingStyle)
: value is DateTimeOffset ? ((DateTimeOffset)value).ToODataString(formattingStyle)
: value is TimeSpan ? ((TimeSpan)value).ToODataString(formattingStyle)
: value is Guid ? ((Guid)value).ToODataString(formattingStyle)
: value is bool ? value.ToString().ToLower()
: value is long ? ((long)value).ToODataString(formattingStyle)
: value is ulong ? ((ulong)value).ToODataString(formattingStyle)
: value is float ? ((float)value).ToString(CultureInfo.InvariantCulture)
: value is double ? ((double)value).ToString(CultureInfo.InvariantCulture)
: value is decimal ? ((decimal)value).ToODataString(formattingStyle)
: value.ToString();
}
internal string Format(ExpressionContext context)
{
if (_operator == ExpressionOperator.None && _conversionType == null)
{
return this.Reference != null ?
FormatReference(context) : this.Function != null ?
FormatFunction(context) :
FormatValue(context);
}
else if (_conversionType != null)
{
var expr = _left;
if (expr.Reference == null && expr.Function == null)
{
object result;
if (Utils.TryConvert(expr.Value, _conversionType, out result))
{
expr = new ODataExpression(result);
}
}
return FormatExpression(expr, context);
}
else if (_operator == ExpressionOperator.NOT || _operator == ExpressionOperator.NEG)
{
var left = FormatExpression(_left, context);
var op = FormatOperator(context);
if (NeedsGrouping(_left))
return string.Format("{0}({1})", op, left);
else
return string.Format("{0} {1}", op, left);
}
else
{
var left = FormatExpression(_left, context);
var right = FormatExpression(_right, context);
var op = FormatOperator(context);
if (NeedsGrouping(_left))
return string.Format("({0}) {1} {2}", left, op, right);
else if (NeedsGrouping(_right))
return string.Format("{0} {1} ({2})", left, op, right);
else
return string.Format("{0} {1} {2}", left, op, right);
}
}
private string FormatFunction(ExpressionContext context)
{
FunctionMapping mapping;
var adapterVersion = context.Session == null ? AdapterVersion.Default : context.Session.Adapter.AdapterVersion;
if (FunctionMapping.TryGetFunctionMapping(this.Function.FunctionName, this.Function.Arguments.Count(), adapterVersion, out mapping))
{
var mappedFunction = mapping.FunctionMapper(this.Function.FunctionName, _functionCaller.Format(context), this.Function.Arguments).Function;
var formattedArguments = string.Join(",", (IEnumerable<object>)mappedFunction.Arguments.Select(x => FormatExpression(x, context)));
return string.Format("{0}({1})",
mappedFunction.FunctionName, formattedArguments);
}
else if (string.Equals(this.Function.FunctionName, ODataLiteral.Any, StringComparison.OrdinalIgnoreCase) ||
string.Equals(this.Function.FunctionName, ODataLiteral.All, StringComparison.OrdinalIgnoreCase))
{
var formattedArguments = string.Format("x{0}:x{0}/{1}",
ArgumentCounter >= 0 ? (1 + (ArgumentCounter++) % 9).ToString() : string.Empty,
FormatExpression(this.Function.Arguments.First(), new ExpressionContext(context.Session,
new EntityCollection(_functionCaller.Reference, context.EntityCollection))));
return string.Format("{0}/{1}({2})",
_functionCaller.Format(context), this.Function.FunctionName.ToLower(), formattedArguments);
}
else if (string.Equals(this.Function.FunctionName, ODataLiteral.IsOf, StringComparison.OrdinalIgnoreCase) ||
string.Equals(this.Function.FunctionName, ODataLiteral.Cast, StringComparison.OrdinalIgnoreCase))
{
var formattedArguments = string.Empty;
if (!ReferenceEquals(this.Function.Arguments.First(), null) && !this.Function.Arguments.First().IsNull)
{
formattedArguments += FormatExpression(this.Function.Arguments.First(), new ExpressionContext(context.Session));
formattedArguments += ",";
}
formattedArguments += FormatExpression(this.Function.Arguments.Last(), new ExpressionContext(context.Session));
return string.Format("{0}({1})",
this.Function.FunctionName.ToLower(), formattedArguments);
}
else
{
throw new NotSupportedException(string.Format("The function {0} is not supported or called with wrong number of arguments", this.Function.FunctionName));
}
}
private string FormatScope(string text, ExpressionContext context)
{
return string.IsNullOrEmpty(context.ScopeQualifier)
? text
: string.Format("{0}/{1}", context.ScopeQualifier, text);
}
internal string Format(ExpressionContext context)
{
if (context.IsQueryOption && _operator != ExpressionOperator.None &&
_operator != ExpressionOperator.AND && _operator != ExpressionOperator.EQ)
{
throw new InvalidOperationException("Invalid custom query option");
}
if (_operator == ExpressionOperator.None && _conversionType == null)
{
return this.Reference != null ?
FormatReference(context) : this.Function != null ?
FormatFunction(context) :
FormatValue(context);
}
else if (_conversionType != null)
{
var expr = _left;
if (expr.Reference == null && expr.Function == null && expr._conversionType == null)
{
object result;
if (expr.Value != null && expr.Value.GetType().IsEnumType())
{
expr = new ODataExpression(expr.Value);
}
else if (Utils.TryConvert(expr.Value, _conversionType, out result))
{
expr = new ODataExpression(result);
}
}
return FormatExpression(expr, context);
}
else if (_operator == ExpressionOperator.NOT || _operator == ExpressionOperator.NEG)
{
var left = FormatExpression(_left, context);
var op = FormatOperator(context);
if (NeedsGrouping(_left))
return string.Format("{0}({1})", op, left);
else
return string.Format("{0} {1}", op, left);
}
else
{
var left = FormatExpression(_left, context);
var right = FormatExpression(_right, context);
var op = FormatOperator(context);
if (context.IsQueryOption)
{
return string.Format("{0}{1}{2}", left, op, right);
}
else
{
if (NeedsGrouping(_left))
return string.Format("({0}) {1} {2}", left, op, right);
else if (NeedsGrouping(_right))
return string.Format("{0} {1} ({2})", left, op, right);
else
return string.Format("{0} {1} {2}", left, op, right);
}
}
}
private string FormatAsFunction(string objectName, ExpressionContext context)
{
FunctionMapping mapping;
if (FunctionMapping.SupportedFunctions.TryGetValue(new ExpressionFunction.FunctionCall(objectName, 0), out mapping))
{
string targetName = _functionCaller.Format(context);
var mappedFunction = mapping.FunctionMapper(objectName, targetName, null).Function;
return string.Format("{0}({1})", mappedFunction.FunctionName, targetName);
}
else
{
return null;
}
}
private IEnumerable<string> BuildReferencePath(List<string> pathNames, Table table, List<string> elementNames, ExpressionContext context)
{
if (!elementNames.Any())
{
return pathNames;
}
var objectName = elementNames.First();
if (table != null)
{
if (table.HasColumn(objectName))
{
pathNames.Add(table.FindColumn(objectName).ActualName);
return BuildReferencePath(pathNames, null, elementNames.Skip(1).ToList(), context);
}
else if (table.HasAssociation(objectName))
{
var association = table.FindAssociation(objectName);
pathNames.Add(association.ActualName);
return BuildReferencePath(pathNames, context.Schema.FindTable(association.ReferenceTableName), elementNames.Skip(1).ToList(), context);
}
else
{
var formattedFunction = FormatAsFunction(objectName, context);
if (!string.IsNullOrEmpty(formattedFunction))
{
pathNames.Add(formattedFunction);
return BuildReferencePath(pathNames, null, elementNames.Skip(1).ToList(), context);
}
else
{
throw new UnresolvableObjectException(objectName, string.Format("Invalid referenced object {0}", objectName));
}
}
}
else if (FunctionMapping.SupportedFunctions.ContainsKey(new ExpressionFunction.FunctionCall(elementNames.First(), 0)))
{
var formattedFunction = FormatAsFunction(objectName, context);
pathNames.Add(formattedFunction);
return BuildReferencePath(pathNames, null, elementNames.Skip(1).ToList(), context);
}
else
{
pathNames.AddRange(elementNames);
return BuildReferencePath(pathNames, null, new List<string>(), context);
}
}
private EntityCollection NavigateToCollection(ExpressionContext context, EntityCollection rootCollection, string path)
{
var items = path.Split('/');
var associationName = context.Session.Metadata.GetNavigationPropertyExactName(rootCollection.Name, items.First());
var entityCollection = context.Session.Metadata.GetEntityCollection(
context.Session.Metadata.GetNavigationPropertyPartnerName(rootCollection.Name, associationName));
if (items.Count() == 1)
{
return entityCollection;
}
else
{
path = path.Substring(items.First().Length + 1);
return NavigateToCollection(context, entityCollection, path);
}
}
public string FormatExpressionValue(object value, ExpressionContext context)
{
return FormatValue(value, FormattingStyle.QueryString, context);
}
private string FormatValue(ExpressionContext context)
{
return (new ValueFormatter()).FormatExpressionValue(Value, context);
}
private string FormatFunction(ExpressionContext context)
{
FunctionMapping mapping;
var adapterVersion = context.Session == null ? AdapterVersion.Default : context.Session.Adapter.AdapterVersion;
if (FunctionMapping.TryGetFunctionMapping(this.Function.FunctionName, this.Function.Arguments.Count(), adapterVersion, out mapping))
{
return FormatMappedFunction(context, mapping);
}
else if (string.Equals(this.Function.FunctionName, ODataLiteral.Any, StringComparison.OrdinalIgnoreCase) ||
string.Equals(this.Function.FunctionName, ODataLiteral.All, StringComparison.OrdinalIgnoreCase))
{
return FormatAnyAllFunction(context);
}
else if (string.Equals(this.Function.FunctionName, ODataLiteral.IsOf, StringComparison.OrdinalIgnoreCase) ||
string.Equals(this.Function.FunctionName, ODataLiteral.Cast, StringComparison.OrdinalIgnoreCase))
{
return FormatIsOfCastFunction(context);
}
else if (string.Equals(this.Function.FunctionName, "get_Item", StringComparison.Ordinal) &&
this.Function.Arguments.Count == 1)
{
return FormatArrayIndexFunction(context);
}
else if (string.Equals(this.Function.FunctionName, "ToString", StringComparison.Ordinal) &&
this.Function.Arguments.Count == 0)
{
return _functionCaller.Reference;
}
else if (_functionCaller.IsNull && this.Function.Arguments.Count == 1)
{
var val = this.Function.Arguments.First();
if (val.Value != null)
{
var formattedVal = ODataExpression.FromValue(
string.Equals(this.Function.FunctionName, "ToBoolean", StringComparison.Ordinal) ? Convert.ToBoolean(val.Value) :
string.Equals(this.Function.FunctionName, "ToByte", StringComparison.Ordinal) ? Convert.ToByte(val.Value) :
string.Equals(this.Function.FunctionName, "ToChar", StringComparison.Ordinal) ? Convert.ToChar(val.Value) :
string.Equals(this.Function.FunctionName, "ToDateTime", StringComparison.Ordinal) ? Convert.ToDateTime(val.Value) :
string.Equals(this.Function.FunctionName, "ToDecimal", StringComparison.Ordinal) ? Convert.ToDecimal(val.Value) :
string.Equals(this.Function.FunctionName, "ToDouble", StringComparison.Ordinal) ? Convert.ToDouble(val.Value) :
string.Equals(this.Function.FunctionName, "ToInt16", StringComparison.Ordinal) ? Convert.ToInt16(val.Value) :
string.Equals(this.Function.FunctionName, "ToInt32", StringComparison.Ordinal) ? Convert.ToInt32(val.Value) :
string.Equals(this.Function.FunctionName, "ToInt64", StringComparison.Ordinal) ? Convert.ToInt64(val.Value) :
string.Equals(this.Function.FunctionName, "ToSByte", StringComparison.Ordinal) ? Convert.ToSByte(val.Value) :
string.Equals(this.Function.FunctionName, "ToSingle", StringComparison.Ordinal) ? Convert.ToSingle(val.Value) :
string.Equals(this.Function.FunctionName, "ToString", StringComparison.Ordinal) ? Convert.ToString(val.Value) :
string.Equals(this.Function.FunctionName, "ToUInt16", StringComparison.Ordinal) ? Convert.ToUInt16(val.Value) :
string.Equals(this.Function.FunctionName, "ToUInt32", StringComparison.Ordinal) ? Convert.ToUInt32(val.Value) :
string.Equals(this.Function.FunctionName, "ToUInt64", StringComparison.Ordinal) ? (object)Convert.ToUInt64(val.Value)
: null);
if (formattedVal.Value != null)
return FormatExpression(formattedVal, context);
}
}
throw new NotSupportedException(string.Format("The function {0} is not supported or called with wrong number of arguments", this.Function.FunctionName));
}
private IEnumerable<string> BuildReferencePath(List<string> segmentNames, EntityCollection entityCollection, List<string> elementNames, ExpressionContext context)
{
if (!elementNames.Any())
{
return segmentNames;
}
var objectName = elementNames.First();
if (entityCollection != null)
{
if (context.Session.Metadata.HasStructuralProperty(entityCollection.Name, objectName))
{
var propertyName = context.Session.Metadata.GetStructuralPropertyExactName(
entityCollection.Name, objectName);
segmentNames.Add(propertyName);
return BuildReferencePath(segmentNames, null, elementNames.Skip(1).ToList(), context);
}
else if (context.Session.Metadata.HasNavigationProperty(entityCollection.Name, objectName))
{
var propertyName = context.Session.Metadata.GetNavigationPropertyExactName(
entityCollection.Name, objectName);
var linkName = context.Session.Metadata.GetNavigationPropertyPartnerName(
entityCollection.Name, objectName);
var linkedEntityCollection = context.Session.Metadata.GetEntityCollection(linkName);
segmentNames.Add(propertyName);
return BuildReferencePath(segmentNames, linkedEntityCollection, elementNames.Skip(1).ToList(), context);
}
else if (IsFunction(objectName, context))
{
var formattedFunction = FormatAsFunction(objectName, context);
segmentNames.Add(formattedFunction);
return BuildReferencePath(segmentNames, null, elementNames.Skip(1).ToList(), context);
}
else if (context.Session.Metadata.IsOpenType(entityCollection.Name))
{
segmentNames.Add(objectName);
return BuildReferencePath(segmentNames, null, elementNames.Skip(1).ToList(), context);
}
else
{
throw new UnresolvableObjectException(objectName, string.Format("Invalid referenced object {0}", objectName));
}
}
else if (FunctionMapping.ContainsFunction(elementNames.First(), 0))
{
var formattedFunction = FormatAsFunction(objectName, context);
segmentNames.Add(formattedFunction);
return BuildReferencePath(segmentNames, null, elementNames.Skip(1).ToList(), context);
}
else
{
segmentNames.AddRange(elementNames);
return BuildReferencePath(segmentNames, null, new List<string>(), context);
}
}
private string FormatValue(ExpressionContext context)
{
if (Value is ODataExpression)
{
return (Value as ODataExpression).Format(context);
}
else if (Value is Type)
{
var typeName = context.Session.Adapter.GetMetadata().GetEntityCollectionQualifiedTypeName((Value as Type).Name);
return context.Session.Adapter.ConvertValueToUriLiteral(typeName);
}
else
{
return context.Session.Adapter.ConvertValueToUriLiteral(Value);
}
}
private string FormatFunction(ExpressionContext context)
{
FunctionMapping mapping;
var adapterVersion = context.Session == null ? AdapterVersion.Default : context.Session.Adapter.AdapterVersion;
if (FunctionMapping.TryGetFunctionMapping(this.Function.FunctionName, this.Function.Arguments.Count(), adapterVersion, out mapping))
{
return FormatMappedFunction(context, mapping);
}
else if (string.Equals(this.Function.FunctionName, ODataLiteral.Any, StringComparison.OrdinalIgnoreCase) ||
string.Equals(this.Function.FunctionName, ODataLiteral.All, StringComparison.OrdinalIgnoreCase))
{
return FormatAnyAllFunction(context);
}
else if (string.Equals(this.Function.FunctionName, ODataLiteral.IsOf, StringComparison.OrdinalIgnoreCase) ||
string.Equals(this.Function.FunctionName, ODataLiteral.Cast, StringComparison.OrdinalIgnoreCase))
{
return FormatIsOfCastFunction(context);
}
else if (string.Equals(this.Function.FunctionName, "get_Item", StringComparison.Ordinal) &&
this.Function.Arguments.Count == 1)
{
return FormatArrayIndexFunction(context);
}
else if (string.Equals(this.Function.FunctionName, "ToString", StringComparison.Ordinal) &&
this.Function.Arguments.Count == 0)
{
return _functionCaller.Reference;
}
else
{
throw new NotSupportedException(string.Format("The function {0} is not supported or called with wrong number of arguments", this.Function.FunctionName));
}
}
private string FormatArrayIndexFunction(ExpressionContext context)
{
var propertyName =
FormatExpression(this.Function.Arguments.First(), new ExpressionContext(context.Session)).Trim('\'');
return _functionCaller.Reference == context.DynamicPropertiesContainerName
? propertyName
: string.Format("{0}.{1}", _functionCaller.Reference, propertyName);
}
private string FormatIsOfCastFunction(ExpressionContext context)
{
var formattedArguments = string.Empty;
if (!ReferenceEquals(this.Function.Arguments.First(), null) && !this.Function.Arguments.First().IsNull)
{
formattedArguments += FormatExpression(this.Function.Arguments.First(), new ExpressionContext(context.Session));
formattedArguments += ",";
}
formattedArguments += FormatExpression(this.Function.Arguments.Last(), new ExpressionContext(context.Session));
return string.Format("{0}({1})",
this.Function.FunctionName.ToLower(), formattedArguments);
}
private string FormatReference(ExpressionContext context)
{
var elementNames = new List<string>(this.Reference.Split('.'));
var pathNames = BuildReferencePath(new List<string>(), context.Table, elementNames, context);
return string.Join("/", pathNames);
}
private string FormatOperator(ExpressionContext context)
{
switch (_operator)
{
case ExpressionType.And:
return context.IsQueryOption ? "&" : "and";
case ExpressionType.Or:
return "or";
case ExpressionType.Not:
return "not";
case ExpressionType.Equal:
return context.IsQueryOption ? "=" : "eq";
case ExpressionType.NotEqual:
return "ne";
case ExpressionType.GreaterThan:
return "gt";
case ExpressionType.GreaterThanOrEqual:
return "ge";
case ExpressionType.LessThan:
return "lt";
case ExpressionType.LessThanOrEqual:
return "le";
case ExpressionType.Add:
return "add";
case ExpressionType.Subtract:
return "sub";
case ExpressionType.Multiply:
return "mul";
case ExpressionType.Divide:
return "div";
case ExpressionType.Modulo:
return "mod";
case ExpressionType.Negate:
return "-";
default:
return null;
}
}
private string FormatAsFunction(string objectName, ExpressionContext context)
{
FunctionMapping mapping;
var adapterVersion = context.Session == null ? AdapterVersion.Default : context.Session.Adapter.AdapterVersion;
if (FunctionMapping.TryGetFunctionMapping(objectName, 0, adapterVersion, out mapping))
{
string targetName = _functionCaller.Format(context);
var mappedFunction = mapping.FunctionMapper(objectName, targetName, null).Function;
return string.Format("{0}({1})", mappedFunction.FunctionName, targetName);
}
else
{
return null;
}
}
private string FormatOperator(ExpressionContext context)
{
switch (_operator)
{
case ExpressionOperator.AND:
return "and";
case ExpressionOperator.OR:
return "or";
case ExpressionOperator.NOT:
return "not";
case ExpressionOperator.EQ:
return "eq";
case ExpressionOperator.NE:
return "ne";
case ExpressionOperator.GT:
return "gt";
case ExpressionOperator.GE:
return "ge";
case ExpressionOperator.LT:
return "lt";
case ExpressionOperator.LE:
return "le";
case ExpressionOperator.ADD:
return "add";
case ExpressionOperator.SUB:
return "sub";
case ExpressionOperator.MUL:
return "mul";
case ExpressionOperator.DIV:
return "div";
case ExpressionOperator.MOD:
return "mod";
case ExpressionOperator.NEG:
return "-";
default:
return null;
}
}
private string FormatMappedFunction(ExpressionContext context, FunctionMapping mapping)
{
var mappedFunction = mapping.FunctionMapper(
this.Function.FunctionName, _functionCaller.Format(context), this.Function.Arguments).Function;
var formattedArguments = string.Join(",",
(IEnumerable<object>)mappedFunction.Arguments.Select(x => FormatExpression(x, context)));
return string.Format("{0}({1})",
mappedFunction.FunctionName,
formattedArguments);
}
private bool IsFunction(string objectName, ExpressionContext context)
{
FunctionMapping mapping;
var adapterVersion = context.Session == null ? AdapterVersion.Default : context.Session.Adapter.AdapterVersion;
return FunctionMapping.TryGetFunctionMapping(objectName, 0, adapterVersion, out mapping);
}
private string FormatAnyAllFunction(ExpressionContext context)
{
var navigationPath = _functionCaller.Reference.Replace('.', '/');
var entityCollection = NavigateToCollection(context,
context.EntityCollection, navigationPath);
var formattedArguments = string.Format("x{0}:x{0}/{1}",
ArgumentCounter >= 0 ? (1 + (ArgumentCounter++) % 9).ToString() : string.Empty,
FormatExpression(this.Function.Arguments.First(), new ExpressionContext(context.Session,
entityCollection, context.DynamicPropertiesContainerName)));
return string.Format("{0}/{1}({2})",
context.Session.Adapter.GetCommandFormatter().FormatNavigationPath(context.EntityCollection, navigationPath),
this.Function.FunctionName.ToLower(),
formattedArguments);
}
