public object EvalPropertyPath(object item, NPathIdentifier propertyPath)
        {
            if (propertyPath.Path == "")
            {
                throw new Exception("Can not evaluate propertypath ''");
            }

            if (propertyPath.IsWildcard)
                throw new Exception("Can not evaluate a wildcard path"); // do not localize

            object current = EvalStringPropertyPath(item, propertyPath.Path);
            //idiot conversion is due to roundoff errors when using convert.todouble
            if (IsNumber(current))
                current = double.Parse(current.ToString());

            //negate expression
            if (propertyPath.IsNegative)
            {
                return NegateValue(current);
            }

            return current;
        }
 protected virtual void EmitPropertyPath(NPathIdentifier propertyPath)
 {
     if (propertyPath.IsNegative)
         Write("-");
     Write(propertyPath.Path);
 }
Example #3
0
		private SqlExpression EvalIdentifier(NPathIdentifier identifier)
		{
			
			if (IsEnum(identifier)  )
			{
				throw new NPersistException("Enums should be handled by EvalCompareExpression!");
			}
			else
			{
				if (identifier.ReferenceLocation == NPathPropertyPathReferenceLocation.SelectClause)
				{
					return new SqlColumnAliasReference(propertyPathTraverser.TraverseSimplePropertySpan(identifier.Path)) ;			
				}
				else
				{
					return new SqlColumnAliasReference(propertyPathTraverser.TraversePropertyPath(identifier.Path)) ;
				}
			}
		}
Example #4
0
		private Type GetTypFromPropertyPath(NPathIdentifier identifier)
		{
			string path = identifier.Path;			
			ArrayList properties = propertyPathTraverser.GetPathPropertyMaps (path);
			IPropertyMap property = (IPropertyMap)properties[properties.Count-1];
			//Type type = Type.GetType(property.DataType);
			Type type = this.npathEngine.Context.AssemblyManager.GetTypeFromPropertyMap(property);
	
			if (type == null)
				throw new NullReferenceException(string.Format("Property type returned null for path {0}",path) );

			return type;
		}
        private IValue ParseValue()
        {
            IValue operand = null;

            bool isNegative = false;
            if (tokenizer.GetCurrentToken().IsType("sign"))
            {
                if (tokenizer.GetCurrentToken().IsType("minus"))
                    isNegative = true;

                tokenizer.MoveNext();
            }

            Token currentToken = tokenizer.GetCurrentToken();

            #region parse value

            if (currentToken.IsType("null"))
            {
                NPathNullValue nullOperand = new NPathNullValue();
                operand = nullOperand;
                tokenizer.MoveNext();
            }
            else if (currentToken.IsType("parameter"))
            {
                NPathParameter parameterOperand = new NPathParameter();
                parameterOperand.Value = parameterQueue[0];
                parameterQueue.RemoveAt(0);
                operand = parameterOperand;
                tokenizer.MoveNext();
            }
            else if (tokenizer.GetCurrentToken().IsType("textsearch"))
            {
                return ParseSearchFunctionExpression();
            }
            else if (currentToken.IsType("function") && IsInSelectClause() || currentToken.IsType("isnull") || currentToken.IsType("soundex"))
            {
                NPathFunction functionOperand = new NPathFunction();

                if (currentToken.IsType("soundex"))
                    functionOperand = new NPathSoundexStatement();
                if (currentToken.IsType("sum"))
                    functionOperand = new NPathSumStatement();
                if (currentToken.IsType("isnull"))
                    functionOperand = new NPathIsNullStatement();
                if (currentToken.IsType("count"))
                    functionOperand = new NPathCountStatement();
                if (currentToken.IsType("avg"))
                    functionOperand = new NPathAvgStatement();
                if (currentToken.IsType("min"))
                    functionOperand = new NPathMinStatement();
                if (currentToken.IsType("max"))
                    functionOperand = new NPathMaxStatement();

                tokenizer.MoveNext();
                tokenizer.GetCurrentToken("(", "(");
                tokenizer.MoveNext();
                if (tokenizer.GetCurrentToken().IsType("distinct"))
                {
                    functionOperand.Distinct = true;
                    tokenizer.MoveNext();
                }

                functionOperand.Expression = ParseBooleanExpression();
                tokenizer.GetCurrentToken(")", ")");
                tokenizer.MoveNext();

                operand = functionOperand;
            }
            else if (currentToken.IsType("date"))
            {
                NPathDateTimeValue dateOperand = new NPathDateTimeValue();
                dateOperand.Value = DateTime.Parse(currentToken.Text);
                operand = dateOperand;
                tokenizer.MoveNext();
            }
            else if (currentToken.IsType("decimal"))
            {
                NPathDecimalValue decimalOperand = new NPathDecimalValue();
                decimalOperand.Value = double.Parse(currentToken.Text, NumberFormatInfo.InvariantInfo);
                decimalOperand.IsNegative = isNegative;
                operand = decimalOperand;
                tokenizer.MoveNext();
            }
            else if (currentToken.IsType("string"))
            {
                NPathStringValue stringOperand = new NPathStringValue();
                string text = currentToken.Text;
                text = text.Substring(1, text.Length - 2);

                if (currentToken.IsType("string '")) // do not localize
                    text = text.Replace("''", "'");
                else if (currentToken.IsType("string \""))
                    text = text.Replace("\"\"", "\""); // do not localize

                stringOperand.Value = text;
                operand = stringOperand;
                tokenizer.MoveNext();
            }
            else if (currentToken.IsType("boolean"))
            {
                NPathBooleanValue booleanOperand = new NPathBooleanValue();
                booleanOperand.Value = bool.Parse(currentToken.Text);
                operand = booleanOperand;
                tokenizer.MoveNext();
            }
            else if (currentToken.IsType("guid"))
            {
                NPathGuidValue guidOperand = new NPathGuidValue();
                guidOperand.Value = currentToken.Text;
                operand = guidOperand;
                tokenizer.MoveNext();
            }
            else if (currentToken.IsType("property path")) // do not localize
            {
                if (tokenizer.GetNextToken().IsType("("))
                {
                    string fullPath = currentToken.Text;
                    string propertyPath = "";
                    string methodName = "";
                    int lastIndexOfDot = fullPath.LastIndexOf(".");
                    if (lastIndexOfDot > 0)
                    {
                        propertyPath = fullPath.Substring(0, lastIndexOfDot);
                        methodName = fullPath.Substring(lastIndexOfDot + 1);
                    }
                    else
                    {
                        methodName = fullPath;
                    }

                    NPathMethodCall call = new NPathMethodCall();
                    call.MethodName = methodName;

                    call.PropertyPath = new NPathIdentifier();
                    call.PropertyPath.Path = propertyPath;
                    call.PropertyPath.IsNegative = isNegative;

                    //TODO:add method support here
                    tokenizer.MoveNext(); //move past "("
                    tokenizer.MoveNext();
                    while (!tokenizer.GetCurrentToken().IsType(")"))
                    {
                        IValue param = ParseExpression();
                        call.Parameters.Add(param);
                        if (tokenizer.GetCurrentToken().IsType("comma"))
                        {
                            tokenizer.MoveNext();
                        }
                        else
                        {
                            tokenizer.GetCurrentToken(")", ")");
                        }

                    }
                    tokenizer.MoveNext();
                    operand = call;
                }
                else if (tokenizer.GetNextToken().IsType("["))
                {
                    CurrentPropertyPrefix = currentToken.Text + ".";
                    NPathBracketGroup bracketGroup = new NPathBracketGroup();
                    tokenizer.MoveNext();
                    ParseBracketGroup(bracketGroup);
                    CurrentPropertyPrefix = "";
                    NPathParenthesisGroup parens = new NPathParenthesisGroup();
                    parens.Expression = bracketGroup.Expression;
                    operand = parens;
                }
                else
                {
                    NPathIdentifier propertyOperand = new NPathIdentifier();
                    propertyOperand.Path = CurrentPropertyPrefix + currentToken.Text;

                    propertyOperand.ReferenceLocation = IsInSelectClause() ? NPathPropertyPathReferenceLocation.SelectClause : NPathPropertyPathReferenceLocation.WhereClause;

                    //CurrentQuery.AddPropertyPathReference(propertyOperand.Path) ;

                    propertyOperand.IsNegative = isNegative;
                    operand = propertyOperand;
                    tokenizer.MoveNext();
                }
            }
            else if (currentToken.IsType("("))
            {
                NPathParenthesisGroup parenthesisOperand = new NPathParenthesisGroup();
                ParseParenthesisGroup(parenthesisOperand);
                parenthesisOperand.IsNegative = isNegative;
                operand = parenthesisOperand;
            }
            else
            {
                //unknown value?
                throw GetUnknownTokenException();
            }

            #endregion

            return operand;
        }
        private IValue ParseSearchFunctionExpression()
        {
            NPathSearchFunction search = new NPathSearchFunction();

            search.FunctionName = tokenizer.GetCurrentToken().Text;

            tokenizer.MoveNext();
            tokenizer.GetCurrentToken("(", "(");
            tokenizer.MoveNext();
            NPathIdentifier path = new NPathIdentifier();
            path.Path = CurrentPropertyPrefix + tokenizer.GetCurrentToken("property path", "Property path").Text; // do not localize

            path.ReferenceLocation = IsInSelectClause() ? NPathPropertyPathReferenceLocation.SelectClause : NPathPropertyPathReferenceLocation.WhereClause;
            //	CurrentQuery.AddPropertyPathReference(path.Path) ;

            search.PropertyPath = path;
            tokenizer.MoveNext();
            tokenizer.GetCurrentToken("comma", ",");
            tokenizer.MoveNext();
            tokenizer.GetCurrentToken("string", new string[] {"\"", "'"});
            search.SearchString = (NPathStringValue) ParseValue();

            tokenizer.GetCurrentToken(")", ")"); // do not localize
            tokenizer.MoveNext();

            return search;
        }
        public void ExpandWildcards(NPathSelectQuery query)
        {
            ArrayList newSelectFieldList = new ArrayList();
            foreach (NPathSelectField field in query.Select.SelectFields)
            {
                string fieldName = field.Alias;
                NPathIdentifier path = field.Expression as NPathIdentifier;
                if (path != null && path.IsWildcard)
                {
                    string[] parts = path.Path.Split('.');
                    NPathClassName className = (NPathClassName) query.From.Classes[0];

                    IClassMap classMap = Context.DomainMap.MustGetClassMap(className.Name);

                    int i = 0;
                    foreach (string part in parts)
                    {
                        if (i == parts.Length - 1)
                            break;

                        IPropertyMap property = classMap.MustGetPropertyMap(part);
                        classMap = Context.DomainMap.MustGetClassMap(property.DataType);
                        i++;
                    }

                    ArrayList properties = classMap.GetAllPropertyMaps();

                    foreach (PropertyMap property in properties)
                    {
                        if (property.ReferenceType != ReferenceType.None)
                            continue;

                        NPathSelectField newField = new NPathSelectField();
                        newField.Alias = null;
                        NPathIdentifier newPath = new NPathIdentifier();
                        if (parts.Length > 1)
                            newPath.Path = string.Join(".", parts, 0, parts.Length - 1) + ".";

                        newPath.Path += property.Name;
                        newField.Expression = newPath;
                        newSelectFieldList.Add(newField);
                    }
                }
                else
                {
                    newSelectFieldList.Add(field);
                }
            }
            query.Select.SelectFields = newSelectFieldList;
        }