Exemple #1
0
        public override void Visit(LikePredicate predicate)
        {
            if (Array.IndexOf(options, "INSENSITIVE_LIKE") != -1)
            {
                /// TODO: Test the three cases of % placement to create a ^ and a $ in the regexp
                _Query.Append(REGEXP_LIKE).Append(OPENBRACE);
                predicate.MatchValue.Accept(this);
                _Query.Append(COMMA).Append(SINGLEQUOTE).Append(FormatValue(predicate.Pattern, DbType.String)).Replace("%", String.Empty).Append(SINGLEQUOTE).Append(COMMA).Append("'i'").Append(CLOSEBRACE);

                if (!Char.IsWhiteSpace(predicate.CharacterEscape))
                    _Query.Append(ESCAPE).Append(SINGLEQUOTE).Append(predicate.CharacterEscape).Append(SINGLEQUOTE).Append(SPACE);
            }
            else
                base.Visit(predicate);
        }
Exemple #2
0
        public override void Visit(BinaryOperator binaryop)
        {
            bool firstIsType = ((int)_ExprLevel.Peek() == EXPR);
            _ExprLevel.Push(_ExprLevel.Peek());

            ISQLExpression expression = null;

            EntityMapping entityMap = null;
            if (!firstIsType)
                entityMap = (EntityMapping)entityMappingContext.Peek();

            //	Try to get the queried attribute. If it is a date type and the 
            //	corresponding mapping is generic, we have to convert the value as ticks
            //	instead of the standard representation

            Value val = binaryop.LeftOperand as Value;
            Path path = binaryop.LeftOperand as Path;

            if (val == null)
                val = binaryop.RightOperand as Value;

            if (path == null)
                path = binaryop.RightOperand as Path;

            if (!firstIsType)
            {
                if (val != null && path != null && path.Identifiers.Count == 1)
                {
                    AttributeMapping am = entityMap.Attributes[path.Identifiers[path.Identifiers.Count - 1].Value, true];

                    if (val.Type == ValueEnum.Date)
                    {
                        //	If the field type isn't date type, convert the value as ticks
                        if (am.DbType != DbType.Date && am.DbType != DbType.DateTime && am.DbType != DbType.Time)
                        {
                            DateTime dt = Convert.ToDateTime(val.Text);
                            val.Text = Common.Utils.ConvertToString(dt, dt.GetType());
                        }
                    }
                }
            }

            ISQLExpression discriminatorConstraint = null;
            Path p = binaryop.LeftOperand as Path;
            if (p == null)
                p = binaryop.RightOperand as Path;

            if (p != null && !firstIsType)
            {
                AttributeMapping am = entityMap.Attributes[p.Identifiers[p.Identifiers.Count - 1].Value];

                if (am != null &&
                    am.Discriminator != null &&
                    am.Discriminator != string.Empty &&
                    am.DiscriminatorValue != null &&
                    am.DiscriminatorValue != string.Empty)
                {
                    Column left = new Column(am, am.Discriminator);
                    Constant right = new Constant(path.Identifiers[path.Identifiers.Count - 1].Value, DbType.AnsiStringFixedLength);
                    discriminatorConstraint = new BinaryLogicExpression(
                        left,
                        BinaryLogicOperator.Equals,
                        right);
                }
            }

            switch (binaryop.Type)
            {
                case BinaryOperatorEnum.And:
                    binaryop.LeftOperand.Accept(this);
                    ISQLExpression leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    ISQLExpression rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new BinaryLogicExpression(leftValueExpression, BinaryLogicOperator.And, rightValueExpression);

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);

                    break;
                case BinaryOperatorEnum.Or:
                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new BinaryLogicExpression(leftValueExpression, BinaryLogicOperator.Or, rightValueExpression);

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);

                    break;
                case BinaryOperatorEnum.Equal:

                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new BinaryLogicExpression(leftValueExpression, BinaryLogicOperator.Equals, rightValueExpression);

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);

                    break;
                case BinaryOperatorEnum.Greater:
                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new BinaryLogicExpression(leftValueExpression, BinaryLogicOperator.Greater, rightValueExpression);

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);
                    break;

                case BinaryOperatorEnum.GreaterOrEqual:
                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new BinaryLogicExpression(leftValueExpression, BinaryLogicOperator.GreaterOrEquals, rightValueExpression);

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);
                    break;
                case BinaryOperatorEnum.Lesser:
                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new BinaryLogicExpression(leftValueExpression, BinaryLogicOperator.Lesser, rightValueExpression);

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);
                    break;
                case BinaryOperatorEnum.LesserOrEqual:
                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new BinaryLogicExpression(leftValueExpression, BinaryLogicOperator.LesserOrEquals, rightValueExpression);

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);
                    break;

                case BinaryOperatorEnum.NotEqual:
                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new BinaryLogicExpression(leftValueExpression, BinaryLogicOperator.NotEquals, rightValueExpression);

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);
                    break;

                case BinaryOperatorEnum.Plus:
                case BinaryOperatorEnum.Times:
                case BinaryOperatorEnum.Div:
                case BinaryOperatorEnum.Minus:
                case BinaryOperatorEnum.Modulo:
                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new BinaryLogicExpression(leftValueExpression, BinaryOperatorToBinaryLogicOperator(binaryop.Type), rightValueExpression);

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(expression, BinaryLogicOperator.And, discriminatorConstraint);

                    sqlExpressionContext.Push(expression);
                    break;

                case BinaryOperatorEnum.Contains:
                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new LikePredicate(leftValueExpression, String.Format("%{0}%", (string)((Constant)rightValueExpression).Value));

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);
                    break;

                case BinaryOperatorEnum.BeginsWith:
                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new LikePredicate(leftValueExpression, String.Format("{0}%", (string)((Constant)rightValueExpression).Value));

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);

                    break;
                case BinaryOperatorEnum.EndsWith:
                    binaryop.LeftOperand.Accept(this);
                    leftValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    binaryop.RightOperand.Accept(this);
                    rightValueExpression = (ISQLExpression)sqlExpressionContext.Pop();

                    expression = new LikePredicate(leftValueExpression, String.Format("%{0}", (string)((Constant)rightValueExpression).Value));

                    if (discriminatorConstraint != null)
                        expression = new BinaryLogicExpression(
                            expression,
                            BinaryLogicOperator.And,
                            discriminatorConstraint);

                    sqlExpressionContext.Push(expression);

                    break;
            }

            _ExprLevel.Pop();
        }
Exemple #3
0
		public virtual void Visit(LikePredicate predicate)
		{
			predicate.MatchValue.Accept(this);
            _Query.Append(LIKE).Append(FormatValue(predicate.Pattern, DbType.String)).Append(SPACE);

			if (!Char.IsWhiteSpace(predicate.CharacterEscape))
                _Query.Append(ESCAPE).Append(SINGLEQUOTE).Append(predicate.CharacterEscape).Append(SINGLEQUOTE).Append(SPACE);
		}