/// <summary>
        /// Resolves types for the specified expression.
        /// </summary>
        /// <param name="expression">The expression to resolve types for.</param>
        /// <returns>Expression with resolved types.</returns>
        public QueryExpression Visit(QueryFunctionParameterReferenceExpression expression)
        {
            Function          function  = this.CustomFunctionsCallStack.Peek();
            FunctionParameter parameter = function.Parameters.SingleOrDefault(p => p.Name == expression.ParameterName);

            ExceptionUtilities.CheckObjectNotNull(parameter, "Parameter '{0}' does not exist in Function '{1}'.", expression.ParameterName, function.Name);

            QueryType queryType = this.GetDefaultQueryType(parameter.DataType);

            return(new QueryFunctionParameterReferenceExpression(expression.ParameterName, queryType));
        }
        /// <summary>
        /// Replaces function parameter reference expression with an expression represeting argument for the parameter
        /// </summary>
        /// <param name="expression">The function parameter reference expression</param>
        /// <returns>An expression represeting corresponding argument for the parameter</returns>
        protected QueryExpression ReplaceFunctionParameterReference(QueryFunctionParameterReferenceExpression expression)
        {
            string parameterName = expression.ParameterName;
            var    functionCall  = this.customFunctionsCallStack.Peek();
            var    parameters    = functionCall.Function.Parameters;
            var    arguemnts     = functionCall.Arguments;

            var matchingParameters = parameters.Where(p => p.Name == parameterName).ToList();

            ExceptionUtilities.Assert(
                matchingParameters.Count == 1,
                "Found {0} parameters with name '{1}'. Expected: 1. Function: '{2}'.",
                matchingParameters.Count,
                parameterName,
                functionCall.Function.FullName);

            int index = parameters.IndexOf(matchingParameters[0]);

            return(arguemnts[index]);
        }
 /// <summary>
 /// Replaces the given expression.
 /// </summary>
 /// <param name="expression">Expression to replace.</param>
 /// <returns>Replaced expression.</returns>
 public virtual QueryExpression Visit(QueryFunctionParameterReferenceExpression expression)
 {
     return(expression);
 }
Esempio n. 4
0
 /// <summary>
 /// Visits a QueryExpression tree whose root node is the QueryFunctionParameterReferenceExpression.
 /// </summary>
 /// <param name="expression">The root node of the expression tree being visited.</param>
 /// <returns>Uri query string representing the expression.</returns>
 public virtual string Visit(QueryFunctionParameterReferenceExpression expression)
 {
     throw new TaupoNotSupportedException("Not supported");
 }
Esempio n. 5
0
 /// <summary>
 /// Generates System.CodeDom.CodeExpression from the given expression.
 /// </summary>
 /// <param name="expression">Expression from which System.CodeDom.CodeExpression is generated.</param>
 /// <returns>Generated System.CodeDom.CodeExpression.</returns>
 public virtual CodeExpression Visit(QueryFunctionParameterReferenceExpression expression)
 {
     return(Code.Variable(expression.ParameterName));
 }
 /// <summary>
 /// Replaces parameter reference with a corresponding argument of a function call
 /// </summary>
 /// <param name="expression">The expression to replace</param>
 /// <returns>The expression which represents corresponding argument for the parameter reference</returns>
 public override QueryExpression Visit(QueryFunctionParameterReferenceExpression expression)
 {
     return(this.ReplaceFunctionParameterReference(expression));
 }
 /// <summary>
 /// Replaces parameter reference with a corresponding argument of a function call
 /// </summary>
 /// <param name="expression">The expression to replace</param>
 /// <returns>The expression which represents corresponding argument for the parameter reference</returns>
 public override QueryExpression Visit(QueryFunctionParameterReferenceExpression expression)
 {
     return this.ReplaceFunctionParameterReference(expression);
 }
Esempio n. 8
0
 /// <summary>
 /// Evaluates the specified expression.
 /// </summary>
 /// <param name="expression">The expression to evaluate.</param>
 /// <returns>Value of the expression.</returns>
 public QueryValue Visit(QueryFunctionParameterReferenceExpression expression)
 {
     throw new TaupoInvalidOperationException("Should never evaluate function parameter reference");
 }