private static bool CheckShortCircuitAnd(BinaryExpression expression, StringBuilder queryBuilder, Action<Expression> visitExpression)
        {
            if (expression.NodeType == ExpressionType.And || expression.NodeType == ExpressionType.AndAlso)
            {
                var ceLeft = expression.Left as ConstantExpression;
                var ceRight = expression.Right as ConstantExpression;

                if (ceLeft != null && ceLeft.Type == typeof(bool))
                {
                    if ((bool)ceLeft.Value)
                        visitExpression(expression.Right);
                    else
                        queryBuilder.Append("false ");
                    return true;
                }
                else if (ceRight != null && ceRight.Type == typeof(bool))
                {
                    if ((bool)ceRight.Value)
                        visitExpression(expression.Left);
                    else
                        queryBuilder.Append("false ");
                    return true;
                }
            }
            return false;
        }

        private static bool CheckShortCircuitOr(BinaryExpression expression, StringBuilder queryBuilder, Action<Expression> visitExpression)
        {
            if (expression.NodeType == ExpressionType.Or || expression.NodeType == ExpressionType.OrElse)
            {
                var ceLeft = expression.Left as ConstantExpression;
                var ceRight = expression.Right as ConstantExpression;

                if (ceLeft != null && (ceLeft.Type == typeof(bool) || ceLeft.Type == typeof(bool?)))
                {
                    if (true.Equals(ceLeft.Value))
                        queryBuilder.Append("true ");
                    else
                        visitExpression(expression.Right);
                    return true;
                }
                else if (ceRight != null && (ceRight.Type == typeof(bool) || ceRight.Type == typeof(bool?)))
                {
                    if (true.Equals(ceRight.Value))
                        queryBuilder.Append("true ");
                    else
                        visitExpression(expression.Left);
                    return true;
                }
            }
            return false;
        }

		protected override Expression VisitBinary(BinaryExpression binaryExpr)
		{
			ResourceProperty resourceProperty = null;
			object obj = null;
			if (!ExpressionHelper.ContainsComparisonOperator(binaryExpr))
			{
				if (!ExpressionHelper.ContainsLogicalOperator(binaryExpr))
				{
					this.IsCompleteExpressionParsed = false;
				}
			}
			else
			{
				if (!ExpressionHelper.GetPropertyNameAndValue(binaryExpr, out resourceProperty, out obj))
				{
					TraceHelper.Current.DebugMessage("Expression is too complex to execute");
					this.IsCompleteExpressionParsed = false;
				}
				else
				{
					this.FilterProperties.Add(new KeyValuePair<ResourceProperty, object>(resourceProperty, obj));
				}
			}
			return base.VisitBinary(binaryExpr);
		}

        protected List<Microsoft.Z3.BoolExpr> VisitBinary(BinaryExpression b)
        {
            // Use recursion to generate Z3 constraints for each operand of the binary expression
            // left side -> create a Z3 expression representing the left side
            Expression left = Visit(b.Left);

            // right side -> creat a Z3 expression representing the right side
            Expression right = Visit(b.Right);

            // Put those into a Z3 format
            ExpressionType op = b.NodeType;

            using (Context ctx = new Context())
            {
                if (op == ExpressionType.LessThan)
                {
                    // ctx.MkLt(left, right);
                }

            }

            Console.WriteLine(b.ToString());

            // TODO - return a Z3 expression
            return null;
        }

        internal static string GetValueFromEqualsExpression(BinaryExpression be, Type memberDeclaringType, string memberName)
        {
            if (be.NodeType != ExpressionType.Equal)
                throw new Exception("There is a bug in this program.");

            if (be.Left.NodeType == ExpressionType.MemberAccess)
            {
                MemberExpression me = (MemberExpression)be.Left;

                if (IsSameTypeOrSubType(me.Member.DeclaringType, memberDeclaringType) && me.Member.Name == memberName)
                {
                    return GetValueFromExpression(be.Right);
                }
            }
            else if (be.Right.NodeType == ExpressionType.MemberAccess)
            {
                MemberExpression me = (MemberExpression)be.Right;

                if (IsSameTypeOrSubType(me.Member.DeclaringType, memberDeclaringType) && me.Member.Name == memberName)
                {
                    return GetValueFromExpression(be.Left);
                }
            }

            // We should have returned by now.
            throw new Exception("There is a bug in this program.");
        }

        /// <summary>
        /// Validates whether the binary expression is valid AND / OR expression.
        /// </summary>
        /// <param name="binaryExpression">Binary conjuctive expression.</param>
        public static void ValidateConjunctiveExpression(BinaryExpression binaryExpression)
        {
            Utils.ThrowIfNull(binaryExpression, "binaryExpression");

            ExpressionHelper.ValidateConjuctiveNode(binaryExpression.Left);
            ExpressionHelper.ValidateConjuctiveNode(binaryExpression.Right);
        }

        static Expression SimpleProduct(Expression left, Expression right, BinaryExpression product)
        {
            // ensure "left" is no quotient
            if(left.NodeType == ExpressionType.Divide)
            {
                BinaryExpression leftQuotient = (BinaryExpression)left;
                Expression nominator = SimpleProduct(right, leftQuotient.Left, null);
                return SimpleQuotient(nominator, leftQuotient.Right, null);
            }

            // ensure "right" is no quotient
            if(right.NodeType == ExpressionType.Divide)
            {
                BinaryExpression rightQuotient = (BinaryExpression)right;
                Expression nominator = SimpleProduct(left, rightQuotient.Left, null);
                return SimpleQuotient(nominator, rightQuotient.Right, null);
            }

            // ensure "right" is no product
            while(right.NodeType == ExpressionType.Multiply)
            {
                BinaryExpression rightProduct = (BinaryExpression)right;
                left = Expression.Multiply(left, rightProduct.Right);
                right = rightProduct.Left;
            }

            if((product == null) || (left != product.Left) || (right != product.Right))
            {
                return Expression.Multiply(left, right);
            }

            return product;
        }

 protected override Expression VisitBinary(BinaryExpression node)
 {
     switch(node.NodeType) {
     case ExpressionType.Equal:
     case ExpressionType.NotEqual:
       if(_model.IsEntity(node.Left.Type) || _model.IsEntity(node.Right.Type)) {
     //visit children and replace with EntitiesEqual
     var newLeft = Visit(node.Left);
     var newRight = Visit(node.Right);
     var method = node.NodeType == ExpressionType.Equal ? EntityCacheHelper.EntitiesEqualMethod : EntityCacheHelper.EntitiesNotEqualMethod;
     return Expression.Call(null, method, newLeft, newRight);
       }//if
       // compare both args, to cover expr like 'p.Name == null'
       if (node.Left.Type == typeof(string) && node.Right.Type == typeof(string) && _caseMode == StringCaseMode.CaseInsensitive) {
     var baseLeft = base.Visit(node.Left);
     var baseRight = base.Visit(node.Right);
     Expression result = Expression.Call(EntityCacheHelper.StringStaticEquals3Method,
                                          baseLeft, baseRight, EntityCacheHelper.ConstInvariantCultureIgnoreCase);
     if (node.NodeType == ExpressionType.NotEqual)
       result = Expression.Not(result);
     return result;
       }
       break;
       }//switch
       return base.VisitBinary(node);
 }

        protected override Expression VisitBinary(BinaryExpression node)
        {
            string operatorName;
            if (node.Method == null)
            {
                operatorName = string.Format(" {0} ", node.NodeType.GetName());
            }
            else
            {
                // VisitBinary should be called only for operators but its possible
                // that we don't know this special C# operators name

                var name = TypeNameConverter.GetCSharpOperatorName(node.Method);
                if (name != null)
                    operatorName = string.Format(" {0} ", name);
                else
                    operatorName = node.Method.Name;
            }
            // BinaryExpression consists of 3 parts: left operator right
            _rep = string.Format("{0}{1}{2}",
                Print(node.Left),
                operatorName,
                Print(node.Right));

            if (!_isHighLevel)
                _rep = string.Format("({0})", _rep);

            return node;
        }

 protected override Expression VisitBinary(BinaryExpression node)
 {
     var relation = string.Empty;
     switch (node.NodeType)
     {
         case ExpressionType.Equal:
             relation = " = ";
             break;
         case ExpressionType.NotEqual:
             relation = " <> ";
             break;
         case ExpressionType.GreaterThan:
             relation = " > ";
             break;
         case ExpressionType.GreaterThanOrEqual:
             relation = " >= ";
             break;
         case ExpressionType.LessThan:
             relation = " < ";
             break;
         case ExpressionType.LessThanOrEqual:
             relation = " <= ";
             break;
         case ExpressionType.Add:
             relation = " + ";
             break;
         case ExpressionType.Subtract:
             relation = " - ";
             break;
         default:
             break;
     }
     this.Condition = GetRelationCondition(relation, node);
     return node;
 }

 private static void PrintNode(BinaryExpression expression,
   int indent)
 {
     PrintNode(expression.Left, indent + 1);
     PrintSingle(expression, indent);
     PrintNode(expression.Right, indent + 1);
 }

        protected override Expression VisitBinary(BinaryExpression b)
        {
            b = base.VisitBinary(b) as BinaryExpression;

            switch (b.NodeType)
            {
                case ExpressionType.Add:
                case ExpressionType.AddChecked:
                    if (b.Left.Type.Equals(typeof(String)))
                        return Expression.Call(MethodRepository.Concat, Expression.NewArrayInit(Types.String, b.Left, Expressor.ToString(b.Right)));
                    if (b.Right.Type.Equals(typeof(String)))
                        return Expression.Call(MethodRepository.Concat, Expression.NewArrayInit(Types.String, Expressor.ToString(b.Left), b.Right));
                    return b;
                case ExpressionType.ArrayIndex:
                    if (b.Type == Types.Byte)
                    {

                    }
                    return b;
                case ExpressionType.Equal:
                case ExpressionType.NotEqual:
                default:
                    return b;
            }
        }

		protected override Expression VisitBinary(BinaryExpression binaryExpression)
		{
			var nodeType = binaryExpression.NodeType;

			if (nodeType == ExpressionType.Equal || nodeType == ExpressionType.NotEqual)
			{
				var left = this.Visit(binaryExpression.Left).StripAndGetConstant();
				var right = this.Visit(binaryExpression.Right).StripAndGetConstant();

				if (left != null && right != null)
				{
					if (left.Value == null && right.Value == null)
					{
						return Expression.Constant(true);
					}

					if (left.Value == null || right.Value == null)
					{
						return Expression.Constant(false);
					}
				}

				if (left != null && left.Value == null)
				{
					return new SqlFunctionCallExpression(binaryExpression.Type, nodeType == ExpressionType.Equal ? SqlFunction.IsNull : SqlFunction.IsNotNull, binaryExpression.Right);
				}
				else if (right != null && right.Value == null)
				{
					return new SqlFunctionCallExpression(binaryExpression.Type, nodeType == ExpressionType.Equal ? SqlFunction.IsNull : SqlFunction.IsNotNull, binaryExpression.Left);
				}
			}

			return base.VisitBinary(binaryExpression);
		}

        protected override Expression VisitBinary(BinaryExpression binaryExpression)
        {
            var left = this.Visit(binaryExpression.Left);
            var right = this.Visit(binaryExpression.Right);

            if (left.Type.GetUnwrappedNullableType().IsEnum)
            {
                if (!right.Type.GetUnwrappedNullableType().IsEnum)
                {
                    right = Expression.Convert(Expression.Call(null, MethodInfoFastRef.EnumToObjectMethod, Expression.Constant(left.Type.GetUnwrappedNullableType()), Expression.Convert(right, typeof(int))), left.Type);
                }
            }
            else if (right.Type.GetUnwrappedNullableType().IsEnum)
            {
                if (!left.Type.GetUnwrappedNullableType().IsEnum)
                {
                    left = Expression.Convert(Expression.Call(null, MethodInfoFastRef.EnumToObjectMethod, Expression.Constant(right.Type.GetUnwrappedNullableType()), Expression.Convert(left, typeof(int))), right.Type);
                }
            }

            if (left != binaryExpression.Left || right != binaryExpression.Right)
            {
                return Expression.MakeBinary(binaryExpression.NodeType, left, right);
            }

            return binaryExpression;
        }

        protected override Expression VisitBinary(BinaryExpression binaryExpression)
        {
            if (binaryExpression.NodeType == ExpressionType.Or
                || binaryExpression.NodeType == ExpressionType.And
                || binaryExpression.NodeType == ExpressionType.OrElse
                || binaryExpression.NodeType == ExpressionType.AndAlso
                && binaryExpression.Type.GetUnwrappedNullableType() == typeof(bool))
            {
                var left = this.Visit(binaryExpression.Left);
                var right = this.Visit(binaryExpression.Right);

                if (left.Type.GetUnwrappedNullableType() == typeof(bool) && (left is BitBooleanExpression))
                {
                    left = Expression.Equal(left, Expression.Constant(true));
                }

                if (right.Type.GetUnwrappedNullableType() == typeof(bool) && (right is BitBooleanExpression))
                {
                    right = Expression.Equal(right, Expression.Constant(false));
                }

                if (left != binaryExpression.Left || right != binaryExpression.Right)
                {
                    return Expression.MakeBinary(binaryExpression.NodeType, left, right);
                }
            }

            return base.VisitBinary(binaryExpression);
        }

            protected override Expression VisitBinary(BinaryExpression binary)
            {
                if (_operators.ContainsKey(binary.NodeType))
                {
                    var fragment = _parent.buildSimpleWhereClause(_mapping, binary);
                    _register.Peek()(fragment);

                    return null;
                }

                if ((binary.NodeType == ExpressionType.AndAlso) || (binary.NodeType == ExpressionType.OrElse))
                {
                    var separator = binary.NodeType == ExpressionType.AndAlso
                        ? "and"
                        : "or";

                    var compound = new CompoundWhereFragment(separator);
                    _register.Peek()(compound);
                    _register.Push(child => compound.Add(child));

                    Visit(binary.Left);
                    Visit(binary.Right);

                    _register.Pop();

                    return null;
                }


                throw new NotSupportedException($"Marten does not support the BinaryExpression {binary} (yet).");
            }

        public ContainmentWhereFragment(ISerializer serializer, BinaryExpression binary)
        {
            _serializer = serializer;

            var visitor = new FindMembers();
            visitor.Visit(binary.Left);

            var members = visitor.Members;

            if (members.Count > 1)
            {
                var dict = new Dictionary<string, object>();
                var member = members.Last();
                var value = MartenExpressionParser.Value(binary.Right);
                dict.Add(member.Name, value);

                members.Reverse().Skip(1).Each(m =>
                {
                    dict = new Dictionary<string, object> { { m.Name, dict}};
                });

                _dictionary = dict;
            }
            else
            {
                _dictionary = new Dictionary<string, object>();

                var member = members.Single();
                var value = MartenExpressionParser.Value(binary.Right);
                _dictionary.Add(member.Name, value);

            }
        }

 protected override Expression VisitBinary(BinaryExpression node)
 {
     // rewrite not equal
     if (node.NodeType == ExpressionType.NotEqual)
     {
         return
             Visit(Expression.MakeUnary(ExpressionType.Not,
                 Expression.MakeBinary(ExpressionType.Equal, node.Left, node.Right), node.Type));
     }
     // handle
     _query.Append("(");
     Visit(node.Left);
     switch (node.NodeType)
     {
         case ExpressionType.AndAlso:
             _query.Append(" AND ");
             break;
         case ExpressionType.OrElse:
             _query.Append(" OR ");
             break;
         case ExpressionType.Equal:
             _query.Append(":");
             break;
     }
     Visit(node.Right);
     _query.Append(")");
     // done
     return node;
 }

        protected override Expression VisitBinary(BinaryExpression node)
        {
            // Go and visit the left hand side of this expression
            this.Visit(node.Left);

            // Add the operator in the middle
            switch (node.NodeType)
            {
                case ExpressionType.Equal:
                    this.sql.Append("=");
                break;

                case ExpressionType.And:
                case ExpressionType.AndAlso:
                case ExpressionType.Or:
                case ExpressionType.OrElse:
                    this.sql.Append(",");
                break;

                default:
                    throw new Exception
                    (
                        "Operator Not Known => " + node.NodeType
                    );
            }

            // Operator needs a space after it.
            this.sql.Append(" ");

            // Now visit the right hand side of this expression.
            this.Visit(node.Right);

            return node;
        }

        protected override Expression VisitBinary(BinaryExpression b)
        {
            this.Visit(b.Left);
            switch (b.NodeType) {
                case ExpressionType.And | ExpressionType.AndAlso:
                    sb.Append(" and ");
                    break;
                case ExpressionType.Or:
                    sb.Append(" OR");
                    break;
                case ExpressionType.Equal:
                    sb.Append(" = ");
                    break;
                case ExpressionType.NotEqual:
                    sb.Append(" != ");
                    break;
                case ExpressionType.LessThan:
                    sb.Append(" < ");
                    break;
                case ExpressionType.LessThanOrEqual:
                    sb.Append(" <= ");
                    break;
                case ExpressionType.GreaterThan:
                    sb.Append(" > ");
                    break;
                case ExpressionType.GreaterThanOrEqual:
                    sb.Append(" >= ");
                    break;
                default:
                    throw new NotSupportedException(string.Format("The binary operator '{0}' is not supported by SimpleDB.", b.NodeType));
            }

            this.Visit(b.Right);
            return b;
        }