internal FluentCommand(FluentCommand ancestor)
 {
     _schema = ancestor._schema;
     _parent = ancestor._parent;
     _collectionName = ancestor._collectionName;
     _collectionExpression = ancestor._collectionExpression;
     _derivedCollectionName = ancestor._derivedCollectionName;
     _derivedCollectionExpression = ancestor._derivedCollectionExpression;
     _functionName = ancestor._functionName;
     _keyValues = ancestor._keyValues;
     _namedKeyValues = ancestor._namedKeyValues;
     _entryData = ancestor._entryData;
     _parameters = ancestor._parameters;
     _filter = ancestor._filter;
     _filterExpression = ancestor._filterExpression;
     _filterExpression = ancestor._filterExpression;
     _skipCount = ancestor._skipCount;
     _topCount = ancestor._topCount;
     _expandAssociations = ancestor._expandAssociations;
     _selectColumns = ancestor._selectColumns;
     _orderbyColumns = ancestor._orderbyColumns;
     _computeCount = ancestor._computeCount;
     _inlineCount = ancestor._inlineCount;
     _linkName = ancestor._linkName;
     _linkExpression = ancestor._linkExpression;
 }
 private static List<ODataExpression> MergeArguments(IEnumerable<object> arguments, ODataExpression argument)
 {
     var collection = new List<ODataExpression>();
     collection.AddRange(arguments.Select(ODataExpression.FromValue));
     collection.Add(argument);
     return collection;
 }
 private static string FormatExpression(ODataExpression expr, ExpressionContext context)
 {
     if (ReferenceEquals(expr, null))
     {
         return "null";
     }
     else
     {
         return expr.Format(context);
     }
 }
        protected internal ODataExpression(ODataExpression expression)
        {
            _functionCaller = expression._functionCaller;
            _left = expression._left;
            _right = expression._right;
            _operator = expression._operator;
            _conversionType = expression._conversionType;

            this.Reference = expression.Reference;
            this.Value = expression.Value;
            this.Function = expression.Function;
        }
 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);
     }
 }
Beispiel #6
0
        private static ODataExpression ParseBinaryExpression(ODataExpression leftExpression, ODataExpression rightExpression, Expression operandExpression)
        {
            switch (operandExpression.NodeType)
            {
            case ExpressionType.Equal:
                return(leftExpression == rightExpression);

            case ExpressionType.NotEqual:
                return(leftExpression != rightExpression);

            case ExpressionType.LessThan:
                return(leftExpression < rightExpression);

            case ExpressionType.LessThanOrEqual:
                return(leftExpression <= rightExpression);

            case ExpressionType.GreaterThan:
                return(leftExpression > rightExpression);

            case ExpressionType.GreaterThanOrEqual:
                return(leftExpression >= rightExpression);

            case ExpressionType.And:
            case ExpressionType.AndAlso:
                return(leftExpression && rightExpression);

            case ExpressionType.Or:
            case ExpressionType.OrElse:
                return(leftExpression || rightExpression);

            case ExpressionType.Add:
            case ExpressionType.AddChecked:
                return(leftExpression + rightExpression);

            case ExpressionType.Subtract:
            case ExpressionType.SubtractChecked:
                return(leftExpression - rightExpression);

            case ExpressionType.Multiply:
            case ExpressionType.MultiplyChecked:
                return(leftExpression * rightExpression);

            case ExpressionType.Divide:
                return(leftExpression / rightExpression);

            case ExpressionType.Modulo:
                return(leftExpression % rightExpression);
            }

            throw Utils.NotSupportedExpression(operandExpression);
        }
 public Task UnlinkEntryAsync(ODataExpression expression, IDictionary <string, object> linkedEntryKey)
 {
     return(_client.UnlinkEntryAsync(_command, _command.KeyValues, expression.AsString(_session), linkedEntryKey != null ? linkedEntryKey.ToDictionary() : null, CancellationToken.None));
 }
 public void As(ODataExpression expression)
 {
     _derivedCollectionExpression = expression;
 }
        public FluentCommand As(ODataExpression expression)
        {
            if (IsBatchResponse) return this;

            _details.DerivedCollectionExpression = expression;
            return this;
        }
 public void Link(ODataExpression expression)
 {
     _linkExpression = expression;
 }
 protected DynamicODataExpression(ODataExpression caller, ExpressionFunction function)
     : base(caller, function)
 {
 }
 protected internal ODataExpression(ODataExpression expr, Type conversionType)
 {
     _conversionType = conversionType;
     this.Value      = expr;
 }
Beispiel #13
0
 protected DynamicODataExpression(ODataExpression caller, string reference)
     : base(caller, reference)
 {
 }
Beispiel #14
0
 protected DynamicODataExpression(ODataExpression left, ODataExpression right, ExpressionType expressionOperator)
     : base(left, right, expressionOperator)
 {
 }
Beispiel #15
0
        internal string Format(ExpressionContext context)
        {
            if (context.IsQueryOption && _operator != ExpressionType.Default &&
                _operator != ExpressionType.And && _operator != ExpressionType.Equal)
            {
                throw new InvalidOperationException("Invalid custom query option");
            }

            if (_operator == ExpressionType.Default && _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 == ExpressionType.Not || _operator == ExpressionType.Negate)
            {
                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))
                    {
                        left = string.Format("({0})", left);
                    }
                    if (NeedsGrouping(_right))
                    {
                        right = string.Format("({0})", right);
                    }

                    return(string.Format("{0} {1} {2}", left, op, right));
                }
            }
        }
Beispiel #16
0
 public FluentCommand For(ODataExpression expression)
 {
     Details.CollectionExpression = expression;
     return(this);
 }
Beispiel #17
0
 public FluentCommand Link(ODataExpression expression)
 {
     Details.LinkExpression = expression;
     return(this);
 }
        private FluentCommand Resolve()
        {
            if (!ReferenceEquals(_collectionExpression, null))
            {
                For(_collectionExpression.AsString());
                _collectionExpression = null;
            }

            if (!ReferenceEquals(_derivedCollectionExpression, null))
            {
                As(_derivedCollectionExpression.AsString());
                _derivedCollectionExpression = null;
            }

            if (!ReferenceEquals(_filterExpression, null))
            {
                _namedKeyValues = TryInterpretFilterExpressionAsKey(_filterExpression);
                if (_namedKeyValues == null)
                {
                    _filter = _filterExpression.Format(_schema, this.Table);
                }
                else
                {
                    _topCount = -1;
                }
                _filterExpression = null;
            }

            if (!ReferenceEquals(_linkExpression, null))
            {
                Link(_linkExpression.AsString());
                _linkExpression = null;
            }

            return this;
        }
 internal static ODataExpression FromFunction(string functionName, ODataExpression targetExpression, IEnumerable <Expression> arguments)
 {
     return(new ODataExpression(
                targetExpression,
                new ExpressionFunction(functionName, arguments)));
 }
 protected internal ODataExpression(ODataExpression caller, string reference)
 {
     _functionCaller = caller;
     this.Reference  = reference;
 }
Beispiel #21
0
 protected DynamicODataExpression(ODataExpression caller, ExpressionFunction function)
     : base(caller, function)
 {
 }
 protected DynamicODataExpression(ODataExpression left, ODataExpression right, ExpressionType expressionOperator)
     : base(left, right, expressionOperator)
 {
 }
Beispiel #23
0
 public IBoundClient <ODataEntry> As(ODataExpression expression)
 {
     this.Command.As(expression);
     return(CreateClientForODataEntry());
 }
Beispiel #24
0
 public IBoundClient <ODataEntry> For(ODataExpression expression)
 {
     this.Command.For(expression.Reference);
     return(CreateClientForODataEntry());
 }
Beispiel #25
0
 public FT Filter(ODataExpression expression)
 {
     this.Command.Filter(expression);
     return(this as FT);
 }
 protected internal ODataExpression(ODataExpression caller, ExpressionFunction function)
 {
     _functionCaller = caller;
     this.Function = function;
 }
Beispiel #27
0
 public FT Filter(Expression <Func <T, bool> > expression)
 {
     this.Command.Filter(ODataExpression.FromLinqExpression(expression.Body));
     return(this as FT);
 }
        public FluentCommand Filter(ODataExpression expression)
        {
            if (IsBatchResponse) return this;

            if (ReferenceEquals(_details.FilterExpression, null))
                _details.FilterExpression = expression;
            else
                _details.FilterExpression = _details.FilterExpression && expression;
            return this;
        }
Beispiel #29
0
 public FT QueryOptions(ODataExpression expression)
 {
     this.Command.QueryOptions(expression);
     return(this as FT);
 }
 public Task UnlinkEntryAsync(ODataExpression expression, CancellationToken cancellationToken)
 {
     return(_client.UnlinkEntryAsync(_command, _command.KeyValues, expression.AsString(_session), null, cancellationToken));
 }
Beispiel #31
0
 public FT QueryOptions <U>(Expression <Func <U, bool> > expression)
 {
     this.Command.QueryOptions(ODataExpression.FromLinqExpression(expression.Body));
     return(this as FT);
 }
 public Task UnlinkEntryAsync(ODataExpression expression, ODataEntry linkedEntryKey, CancellationToken cancellationToken)
 {
     return(_client.UnlinkEntryAsync(_command, _command.KeyValues, expression.AsString(_session), linkedEntryKey != null ? linkedEntryKey.ToDictionary() : null, cancellationToken));
 }
Beispiel #33
0
 public IMediaClient Media(ODataExpression expression)
 {
     this.Command.Media(expression);
     return(new MediaClient(_client, _session, this.Command, _dynamicResults));
 }
        protected override Expression VisitMethodCall(MethodCallExpression node)
        {
            if (node.Arguments.Count != 2)
            {
                throw Utils.NotSupportedExpression(node);
            }

            var association = AddNestedExpandAssociationAndGetDeepestChild(node.Arguments[0]);

            switch (node.Method.Name)
            {
            case "Select":
            {
                association.ExpandAssociations.AddRange(ExtractNestedExpandAssociations(node.Arguments[1]));

                return(node);
            }

            case "OrderBy":
            case "ThenBy":
            {
                if ((node.Arguments[0] as MethodCallExpression)?.Method.Name == "Select")
                {
                    throw Utils.NotSupportedExpression(node);
                }

                association.OrderByColumns
                .AddRange(node.Arguments[1]
                          .ExtractColumnNames(_typeCache).Select(c => new ODataOrderByColumn(c, false)));

                return(node);
            }

            case "OrderByDescending":
            case "ThenByDescending":
            {
                if ((node.Arguments[0] as MethodCallExpression)?.Method.Name == "Select")
                {
                    throw Utils.NotSupportedExpression(node);
                }

                association.OrderByColumns
                .AddRange(node.Arguments[1]
                          .ExtractColumnNames(_typeCache).Select(c => new ODataOrderByColumn(c, true)));

                return(node);
            }

            case "Where":
            {
                var filterExpression =
                    ODataExpression.FromLinqExpression((node.Arguments[1] as LambdaExpression)?.Body);
                if (ReferenceEquals(association.FilterExpression, null))
                {
                    association.FilterExpression = filterExpression;
                }
                else
                {
                    association.FilterExpression = association.FilterExpression && filterExpression;
                }

                return(node);
            }

            default:
                throw Utils.NotSupportedExpression(node);
            }
        }
Beispiel #35
0
 protected BoundClient <U> Link <U>(FluentCommand command, ODataExpression expression)
     where U : class
 {
     return(Link <U>(command, expression.Reference));
 }
 protected internal ODataExpression(ODataExpression left, ODataExpression right, ExpressionType expressionOperator)
 {
     _left     = left;
     _right    = right;
     _operator = expressionOperator;
 }
Beispiel #37
0
 /// <summary>
 /// Navigates to the linked entity.
 /// </summary>
 /// <param name="expression">The expression for the link.</param>
 /// <returns>Self.</returns>
 public IBoundClient <T> NavigateTo(ODataExpression expression)
 {
     return(this.Link <T>(this.Command, expression));
 }
 protected internal ODataExpression(ODataExpression caller, ExpressionFunction function)
 {
     _functionCaller = caller;
     this.Function   = function;
 }
Beispiel #39
0
 /// <summary>
 /// Returns an instance of a fluent OData client for the specified collection.
 /// </summary>
 /// <param name="expression">Collection expression.</param>
 /// <returns>
 /// The fluent OData client instance.
 /// </returns>
 public IBoundClient <ODataEntry> For(ODataExpression expression)
 {
     return(new BoundClient <ODataEntry>(this, _session).For(expression));
 }
Beispiel #40
0
        private string FormatClauses(FluentCommand command)
        {
            var text             = string.Empty;
            var extraClauses     = new List <string>();
            var aggregateClauses = new List <string>();

            if (command.CommandData.Any() && !string.IsNullOrEmpty(command.Details.FunctionName) &&
                FunctionFormat == FunctionFormat.Query)
            {
                extraClauses.Add(string.Join("&", command.CommandData.Select(x => string.Format("{0}={1}",
                                                                                                x.Key, ConvertValueToUriLiteral(x.Value, true)))));
            }

            if (command.Details.Filter != null)
            {
                extraClauses.Add(string.Format("{0}={1}", ODataLiteral.Filter, EscapeUnescapedString(command.Details.Filter)));
            }

            if (command.Details.Search != null)
            {
                extraClauses.Add(string.Format("{0}={1}", ODataLiteral.Search, EscapeUnescapedString(command.Details.Search)));
            }

            if (command.Details.QueryOptions != null)
            {
                extraClauses.Add(command.Details.QueryOptions);
            }

            var details = command.Details;

            if (!ReferenceEquals(details.QueryOptionsExpression, null))
            {
                extraClauses.Add(details.QueryOptionsExpression.Format(new ExpressionContext(details.Session, true)));
            }
            if (command.Details.QueryOptionsKeyValues != null)
            {
                foreach (var kv in command.Details.QueryOptionsKeyValues)
                {
                    extraClauses.Add(string.Format("{0}={1}", kv.Key, ODataExpression.FromValue(kv.Value).Format(new ExpressionContext(details.Session))));
                }
            }

            if (command.Details.SkipCount >= 0)
            {
                extraClauses.Add(string.Format("{0}={1}", ODataLiteral.Skip, command.Details.SkipCount));
            }

            if (command.Details.TopCount >= 0)
            {
                extraClauses.Add(string.Format("{0}={1}", ODataLiteral.Top, command.Details.TopCount));
            }

            EntityCollection resultCollection;

            if (command.HasFunction)
            {
                resultCollection = _session.Adapter.GetMetadata().GetFunctionReturnCollection(command.Details.FunctionName);
            }
            else if (command.HasAction)
            {
                resultCollection = _session.Adapter.GetMetadata().GetActionReturnCollection(command.Details.ActionName);
            }
            else
            {
                resultCollection = command.EntityCollection;
            }
            if (resultCollection != null)
            {
                FormatExpandSelectOrderby(extraClauses, resultCollection, command);
            }

            if (command.Details.IncludeCount)
            {
                FormatInlineCount(extraClauses);
            }

            if (command.Details.ComputeCount)
            {
                aggregateClauses.Add(ODataLiteral.Count);
            }

            if (aggregateClauses.Any())
            {
                text += "/" + string.Join("/", aggregateClauses);
            }

            if (extraClauses.Any())
            {
                text += "?" + string.Join("&", extraClauses);
            }

            return(text);
        }
        private bool NeedsGrouping(ODataExpression expr)
        {
            if (_operator == ExpressionOperator.None)
                return false;
            if (ReferenceEquals(expr, null))
                return false;
            if (expr._operator == ExpressionOperator.None)
                return false;

            int outerPrecedence = GetPrecedence(_operator);
            int innerPrecedence = GetPrecedence(expr._operator);
            return outerPrecedence < innerPrecedence;
        }
 protected DynamicODataExpression(ODataExpression caller, string reference)
     : base(caller, reference)
 {
 }
 public FluentCommand Media(ODataExpression expression)
 {
     return Media(expression.Reference);
 }
        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);
                }
            }
        }
 protected internal ODataExpression(ODataExpression left, ODataExpression right, ExpressionOperator expressionOperator)
 {
     _left = left;
     _right = right;
     _operator = expressionOperator;
 }
Beispiel #46
0
 public FluentCommand Media(ODataExpression expression)
 {
     return(Media(expression.Reference));
 }
 public void Filter(ODataExpression expression)
 {
     _filterExpression = expression;
 }
 public void For(ODataExpression expression)
 {
     For(expression.ToString());
 }
 public void As(ODataExpression expression)
 {
     As(expression.ToString());
 }
        private static ODataExpression ParseBinaryExpression(ODataExpression leftExpression, ODataExpression rightExpression, Expression operandExpression)
        {
            switch (operandExpression.NodeType)
            {
                case ExpressionType.Equal:
                    return leftExpression == rightExpression;
                case ExpressionType.NotEqual:
                    return leftExpression != rightExpression;
                case ExpressionType.LessThan:
                    return leftExpression < rightExpression;
                case ExpressionType.LessThanOrEqual:
                    return leftExpression <= rightExpression;
                case ExpressionType.GreaterThan:
                    return leftExpression > rightExpression;
                case ExpressionType.GreaterThanOrEqual:
                    return leftExpression >= rightExpression;
                case ExpressionType.And:
                case ExpressionType.AndAlso:
                    return leftExpression && rightExpression;
                case ExpressionType.Or:
                case ExpressionType.OrElse:
                    return leftExpression || rightExpression;
                case ExpressionType.Add:
                case ExpressionType.AddChecked:
                    return leftExpression + rightExpression;
                case ExpressionType.Subtract:
                case ExpressionType.SubtractChecked:
                    return leftExpression - rightExpression;
                case ExpressionType.Multiply:
                case ExpressionType.MultiplyChecked:
                    return leftExpression * rightExpression;
                case ExpressionType.Divide:
                    return leftExpression / rightExpression;
                case ExpressionType.Modulo:
                    return leftExpression % rightExpression;
            }

            throw Utils.NotSupportedExpression(operandExpression);
        }
 public void Filter(ODataExpression expression)
 {
     _namedKeyValues = TryInterpretFilterExpressionAsKey(expression);
     if (_namedKeyValues == null)
     {
         _filter = expression.Format(_schema, this.Table);
     }
     else
     {
         _topCount = -1;
     }
 }
 protected internal ODataExpression(ODataExpression caller, string reference)
 {
     _functionCaller = caller;
     this.Reference = reference;
 }
 private IDictionary<string, object> TryInterpretFilterExpressionAsKey(ODataExpression expression)
 {
     bool ok = false;
     IDictionary<string, object> namedKeyValues = new Dictionary<string, object>();
     if (!ReferenceEquals(expression, null))
     {
         ok = expression.ExtractEqualityComparisons(namedKeyValues);
     }
     return ok &&
         this.Table.GetKeyNames().Count == namedKeyValues.Count() &&
         this.Table.GetKeyNames().All(namedKeyValues.ContainsKey) ? namedKeyValues : null;
 }
 protected internal ODataExpression(ODataExpression expr, Type conversionType)
 {
     _left = expr;
     _conversionType = conversionType;
 }
 public Task LinkEntryAsync(ODataExpression expression, IDictionary <string, object> linkedEntryKey, CancellationToken cancellationToken)
 {
     return(_client.LinkEntryAsync(_command, _command.KeyValues, expression.AsString(_session), linkedEntryKey.ToDictionary(), cancellationToken));
 }
        public FluentCommand Link(ODataExpression expression)
        {
            if (IsBatchResponse) return this;

            _details.LinkExpression = expression;
            return this;
        }
 public Task LinkEntryAsync(ODataExpression expression, ODataEntry linkedEntryKey)
 {
     return(_client.LinkEntryAsync(_command, _command.KeyValues, expression.AsString(_session), linkedEntryKey.ToDictionary(), CancellationToken.None));
 }
        private IDictionary<string, object> TryInterpretFilterExpressionAsKey(ODataExpression expression)
        {
            bool ok = false;
            IDictionary<string, object> namedKeyValues = new Dictionary<string, object>();
            if (!ReferenceEquals(expression, null))
            {
                ok = expression.ExtractLookupColumns(namedKeyValues);
            }
            if (!ok)
                return null;

            var keyNames = _details.Session.Metadata.GetDeclaredKeyPropertyNames(this.EntityCollection.Name).ToList();
            return keyNames.Count == namedKeyValues.Count() && keyNames.All(namedKeyValues.ContainsKey)
                ? namedKeyValues
                : null;
        }
 public void For(ODataExpression expression)
 {
     _collectionExpression = expression;
 }