Example #1
0
        private void JoinViaFrom(SqlStatement statement, SqlSelect select)
        {
            var queryRef = SqlDml.QueryRef(select, "source");

            SetStatementFrom(statement, queryRef);
            var                 sqlTableRef     = GetStatementTable(statement);
            SqlExpression       whereExpression = null;
            PrimaryIndexMapping indexMapping    = PrimaryIndexes[0];

            foreach (ColumnInfo columnInfo in indexMapping.PrimaryIndex.KeyColumns.Keys)
            {
                var leftColumn  = queryRef.Columns[columnInfo.Name];
                var rightColumn = sqlTableRef == null?GetStatementTable(statement).Columns[columnInfo.Name] : sqlTableRef.Columns[columnInfo.Name];

                if (leftColumn == null || rightColumn == null)
                {
                    throw new InvalidOperationException("Source query doesn't contain one of key columns of updated table.");
                }
                var columnEqualityExperssion = SqlDml.Equals(queryRef.Columns[columnInfo.Name], sqlTableRef.Columns[columnInfo.Name]);
                if (whereExpression == null)
                {
                    whereExpression = columnEqualityExperssion;
                }
                else
                {
                    whereExpression = SqlDml.And(whereExpression, columnEqualityExperssion);
                }
            }
            SetStatementWhere(statement, whereExpression);
        }
Example #2
0
        private void JoinViaIn(SqlStatement statement, SqlSelect @select)
        {
            SqlTableRef table = GetStatementTable(statement);

            SqlExpression where = GetStatementWhere(statement);
            JoinedTableRef      = table;
            PrimaryIndexMapping indexMapping = PrimaryIndexes[0];
            var columns = new List <ColumnInfo>();

            foreach (ColumnInfo columnInfo in indexMapping.PrimaryIndex.KeyColumns.Keys)
            {
                SqlSelect s = select.ShallowClone();
                foreach (ColumnInfo column in columns)
                {
                    SqlBinary ex = SqlDml.Equals(SqlDml.TableColumn(s.From, column.Name), SqlDml.TableColumn(table, column.Name));
                    s.Where = s.Where.IsNullReference() ? ex : SqlDml.And(s.Where, ex);
                }
                s.Columns.Clear();
                s.Columns.Add(SqlDml.TableColumn(s.From, columnInfo.Name));
                SqlBinary @in = SqlDml.In(SqlDml.TableColumn(table, columnInfo.Name), s);
                @where = @where.IsNullReference() ? @in : SqlDml.And(@where, @in);
                columns.Add(columnInfo);
            }
            SetStatementWhere(statement, where);
        }
        private void JoinViaIn(SqlStatement statement, SqlSelect select)
        {
            var table = GetStatementTable(statement);

            var where      = GetStatementWhere(statement);
            JoinedTableRef = table;
            var indexMapping = PrimaryIndexes[0];
            var columns      = new List <ColumnInfo>();

            foreach (var columnInfo in indexMapping.PrimaryIndex.KeyColumns.Keys)
            {
                var s = (SqlSelect)select.Clone();
                foreach (var column in columns)
                {
                    var ex = SqlDml.Equals(s.From.Columns[column.Name], table.Columns[column.Name]);
                    s.Where = s.Where.IsNullReference() ? ex : SqlDml.And(s.Where, ex);
                }
                var existingColumns = s.Columns.ToChainedBuffer();
                s.Columns.Clear();
                var columnToAdd = existingColumns.First(c => c.Name.Equals(columnInfo.Name, StringComparison.Ordinal));
                s.Columns.Add(columnToAdd);
                var @in = SqlDml.In(SqlDml.TableColumn(table, columnInfo.Name), s);
                where = where.IsNullReference() ? @in : SqlDml.And(where, @in);
                columns.Add(columnInfo);
            }

            SetStatementWhere(statement, where);
        }
 public static SqlExpression operator &(SqlExpression left, SqlExpression right)
 {
     if (left.IsNullReference())
     {
         return(right);
     }
     if (right.IsNullReference())
     {
         return(left);
     }
     if (SqlValidator.IsBooleanExpression(left))
     {
         return(SqlDml.And(left, right));
     }
     return(SqlDml.BitAnd(left, right));
 }
        protected override SqlExpression VisitBinary(BinaryExpression expression)
        {
            // handle x.CompareTo(y) > 0 and similar comparisons
            SqlExpression result = TryTranslateCompareExpression(expression);

            if (!result.IsNullReference())
            {
                return(result);
            }

            SqlExpression left;
            SqlExpression right;

            bool isEqualityCheck =
                expression.NodeType == ExpressionType.Equal ||
                expression.NodeType == ExpressionType.NotEqual;

            bool isBooleanFixRequired = fixBooleanExpressions &&
                                        (isEqualityCheck || expression.NodeType == ExpressionType.Coalesce) &&
                                        (IsBooleanExpression(expression.Left) || IsBooleanExpression(expression.Right));

            if (IsCharToIntConvert(expression.Left) && IsCharToIntConvert(expression.Right))
            {
                // chars are compared as integers, but we store them as strings and should compare them like strings.
                left  = Visit(GetOperand(expression.Left), isEqualityCheck);
                right = Visit(GetOperand(expression.Right), isEqualityCheck);
            }
            else if (IsCharToIntConvert(expression.Left) && IsIntConstant(expression.Right))
            {
                // another case of char comparison
                left  = Visit(GetOperand(expression.Left), isEqualityCheck);
                right = ConvertIntConstantToSingleCharString(expression.Right);
            }
            else if (IsIntConstant(expression.Left) && IsCharToIntConvert(expression.Right))
            {
                // another case of char comparison
                left  = ConvertIntConstantToSingleCharString(expression.Left);
                right = Visit(GetOperand(expression.Right), isEqualityCheck);
            }
            else
            {
                // regular case
                left  = Visit(expression.Left, isEqualityCheck);
                right = Visit(expression.Right, isEqualityCheck);
            }
            if (isBooleanFixRequired)
            {
                // boolean expressions should be compared as integers.
                // additional check is required because some type information might be lost.
                // we assume they already have correct format in that case.
                if (IsBooleanExpression(expression.Left))
                {
                    left = booleanExpressionConverter.BooleanToInt(left);
                }
                if (IsBooleanExpression(expression.Right))
                {
                    right = booleanExpressionConverter.BooleanToInt(right);
                }
            }

            //handle SQLite DateTime comparsion
            if (dateTimeEmulation &&
                left.NodeType != SqlNodeType.Null &&
                right.NodeType != SqlNodeType.Null &&
                IsComparisonExpression(expression) &&
                (IsDateTimeExpression(expression.Left) || IsDateTimeExpression(expression.Right)))
            {
                left  = SqlDml.Cast(left, SqlType.DateTime);
                right = SqlDml.Cast(right, SqlType.DateTime);
            }

            //handle SQLite DateTimeOffset comparsion
            if (dateTimeOffsetEmulation &&
                left.NodeType != SqlNodeType.Null &&
                right.NodeType != SqlNodeType.Null &&
                IsComparisonExpression(expression) &&
                (IsDateTimeOffsetExpression(expression.Left) || IsDateTimeOffsetExpression(expression.Right)))
            {
                left  = SqlDml.Cast(left, SqlType.DateTimeOffset);
                right = SqlDml.Cast(right, SqlType.DateTimeOffset);
            }

            // handle special cases
            result = TryTranslateBinaryExpressionSpecialCases(expression, left, right);
            if (!result.IsNullReference())
            {
                return(result);
            }

            // handle overloaded operators
            if (expression.Method != null)
            {
                return(CompileMember(expression.Method, null, left, right));
            }

            //handle wrapped enums
            SqlContainer container = left as SqlContainer;

            if (container != null)
            {
                left = TryUnwrapEnum(container);
            }
            container = right as SqlContainer;
            if (container != null)
            {
                right = TryUnwrapEnum(container);
            }

            switch (expression.NodeType)
            {
            case ExpressionType.Add:
            case ExpressionType.AddChecked:
                return(SqlDml.Add(left, right));

            case ExpressionType.And:
                return(IsBooleanExpression(expression.Left)
          ? SqlDml.And(left, right)
          : SqlDml.BitAnd(left, right));

            case ExpressionType.AndAlso:
                return(SqlDml.And(left, right));

            case ExpressionType.Coalesce:
                SqlExpression coalesce = SqlDml.Coalesce(left, right);
                if (isBooleanFixRequired)
                {
                    coalesce = booleanExpressionConverter.IntToBoolean(coalesce);
                }
                return(coalesce);

            case ExpressionType.Divide:
                return(SqlDml.Divide(left, right));

            case ExpressionType.Equal:
                return(SqlDml.Equals(left, right));

            case ExpressionType.ExclusiveOr:
                return(SqlDml.BitXor(left, right));

            case ExpressionType.GreaterThan:
                return(SqlDml.GreaterThan(left, right));

            case ExpressionType.GreaterThanOrEqual:
                return(SqlDml.GreaterThanOrEquals(left, right));

            case ExpressionType.LessThan:
                return(SqlDml.LessThan(left, right));

            case ExpressionType.LessThanOrEqual:
                return(SqlDml.LessThanOrEquals(left, right));

            case ExpressionType.Modulo:
                return(SqlDml.Modulo(left, right));

            case ExpressionType.Multiply:
            case ExpressionType.MultiplyChecked:
                return(SqlDml.Multiply(left, right));

            case ExpressionType.NotEqual:
                return(SqlDml.NotEquals(left, right));

            case ExpressionType.Or:
                return(IsBooleanExpression(expression.Left)
          ? SqlDml.Or(left, right)
          : SqlDml.BitOr(left, right));

            case ExpressionType.OrElse:
                return(SqlDml.Or(left, right));

            case ExpressionType.Subtract:
            case ExpressionType.SubtractChecked:
                return(SqlDml.Subtract(left, right));

            default:
                throw new ArgumentOutOfRangeException("expression");
            }
        }