public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
{
var column = (Column)StatementPartCreator.Visit(queryModel, ordering.Expression, this.Configuration, this.AliasTables);
switch (ordering.OrderingDirection)
{
case OrderingDirection.Asc:
{
this.SelectStatement.OrderByFields.Add(new OrderByExpression(column, OrderDirection.Ascending));
break;
}
case OrderingDirection.Desc:
{
this.SelectStatement.OrderByFields.Add(new OrderByExpression(column, OrderDirection.Descending));
break;
}
default:
{
throw new InvalidOperationException($"Invalid ordering direction: {ordering.OrderingDirection}");
}
}
base.VisitOrdering(ordering, queryModel, orderByClause, index);
}
public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
{
// TODO: This seems heavy...
// TODO: And like it's only going to deal with certain types of joins
var table = (Table)StatementPartCreator.Visit(queryModel, joinClause.InnerSequence, this.Configuration, this.AliasTables);
table.Alias = joinClause.ItemName.Replace("<generated>", "g");
var leftColumn = (SourceExpression)StatementPartCreator.Visit(queryModel, joinClause.OuterKeySelector, this.Configuration, this.AliasTables);
var rightColumn = (SourceExpression)StatementPartCreator.Visit(queryModel, joinClause.InnerKeySelector, this.Configuration, this.AliasTables);
if (leftColumn is FieldCollection && rightColumn is FieldCollection)
{
var leftColumnCollection = (FieldCollection)leftColumn;
var rightColumnCollection = (FieldCollection)rightColumn;
var joinConditions = new ConditionCollection();
for (var i = 0; i < leftColumnCollection.Count; i++)
{
joinConditions.Add(new Condition(leftColumnCollection[i], SqlOperator.Equals, rightColumnCollection[i]));
}
this.SelectStatement.SourceJoins.Add(new Join(table, joinConditions)
{
JoinType = JoinType.Left
});
}
else
{
this.SelectStatement.SourceJoins.Add(new Join(table, leftColumn, rightColumn)
{
JoinType = JoinType.Left
});
}
base.VisitJoinClause(joinClause, queryModel, index);
}
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
if (selectClause.Selector.NodeType != ExpressionType.Extension)
{
var fields = StatementPartCreator.Visit(queryModel, selectClause.Selector, this.Configuration, this.AliasTables);
this.SelectStatement.SourceFields.Add((SourceExpression)fields);
}
base.VisitSelectClause(selectClause, queryModel);
}
private void VisitPredicate(Expression predicate, QueryModel queryModel)
{
var whereStatement = StatementPartCreator.Visit(queryModel, predicate, this.Configuration, this.AliasTables);
ConditionExpression condition;
if (whereStatement is ConditionExpression)
{
condition = (ConditionExpression)whereStatement;
}
else if (whereStatement is UnaryOperation && ((UnaryOperation)whereStatement).Expression is ConditionExpression)
{
condition = (ConditionExpression)((UnaryOperation)whereStatement).Expression;
}
else if (whereStatement is UnaryOperation && ((UnaryOperation)whereStatement).Expression is Column)
{
var unary = (UnaryOperation)whereStatement;
var column = (Column)unary.Expression;
condition = new Condition(column, SqlOperator.Equals, new ConstantPart(unary.Operator != UnaryOperator.Not));
}
else if (whereStatement is ConstantPart && ((ConstantPart)whereStatement).Value is bool)
{
var value = (bool)((ConstantPart)whereStatement).Value;
condition = new Condition()
{
Field = new ConstantPart(value), Operator = SqlOperator.Equals, Value = new ConstantPart(true)
};
}
else if (whereStatement is Column && ((Column)whereStatement).PropertyType == typeof(bool))
{
condition = new Condition((Column)whereStatement, SqlOperator.Equals, new ConstantPart(true));
}
else
{
throw new InvalidOperationException();
}
this.SelectStatement.Conditions.Add(condition);
}
