public void AndAlso(SqlValueExpression <TEntity, bool> conditionExpression)
{
_expression = _expression.AndAlso(
conditionExpression.QueryExpression
);
AddJoins(conditionExpression.Joins);
}
protected override void WriteFunctionToSql(QueryExpression queryExpression)
{
switch (queryExpression)
{
case ConcatenateQueryExpression concatenateQueryExpression:
for (var i = 0; i < concatenateQueryExpression.Expressions.Length; i++)
{
ExpressionWriter.Visit(concatenateQueryExpression.Expressions[i]);
if (i < concatenateQueryExpression.Expressions.Length - 1)
{
Sql.Append(" || ");
}
}
return;
case LastInsertIdFunctionExpression lastInsertIdExpression:
Sql.Append("last_insert_rowid()");
return;
case TableExistsVirtualFunctionExpression tableExistsExpression:
ExpressionWriter.Visit(
QueryExpression.Select(
new[] { QueryExpression.Value(1) },
from: QueryExpression.Table("sqlite_master"),
where : QueryExpression.AndAlso(
QueryExpression.Compare(QueryExpression.Column("type"), ComparisonOperator.AreEqual, QueryExpression.Value("table")),
QueryExpression.Compare(QueryExpression.Column("name"), ComparisonOperator.AreEqual, QueryExpression.Value(tableExistsExpression.Table.TableName))
)
)
);
return;
}
base.WriteFunctionToSql(queryExpression);
}
public static QueryExpression AndAlso(this QueryExpression left, QueryExpression right)
{
if (left == null)
{
return(right);
}
return(QueryExpression.AndAlso(left, right));
}
protected override Expression VisitBinary(BinaryExpression node)
{
var leftExpression = ConvertToQueryExpression(node.Left);
var rightExpression = ConvertToQueryExpression(node.Right);
switch (node.NodeType)
{
case ExpressionType.AddChecked:
case ExpressionType.Add:
SetConversionResult(
QueryExpression.Add(leftExpression, rightExpression)
);
break;
case ExpressionType.SubtractChecked:
case ExpressionType.Subtract:
SetConversionResult(
QueryExpression.Subtract(leftExpression, rightExpression)
);
break;
case ExpressionType.MultiplyChecked:
case ExpressionType.Multiply:
SetConversionResult(
QueryExpression.Multiply(leftExpression, rightExpression)
);
break;
case ExpressionType.Divide:
SetConversionResult(
QueryExpression.Divide(leftExpression, rightExpression)
);
break;
case ExpressionType.And:
SetConversionResult(
new BitwiseOperationQueryExpression(leftExpression, BitwiseOperator.And, rightExpression)
);
break;
case ExpressionType.ExclusiveOr:
SetConversionResult(
new BitwiseOperationQueryExpression(leftExpression, BitwiseOperator.ExclusiveOr, rightExpression)
);
break;
case ExpressionType.Or:
SetConversionResult(
new BitwiseOperationQueryExpression(leftExpression, BitwiseOperator.Or, rightExpression)
);
break;
case ExpressionType.AndAlso:
SetConversionResult(
QueryExpression.AndAlso(leftExpression, rightExpression)
);
break;
case ExpressionType.OrElse:
SetConversionResult(
QueryExpression.OrElse(leftExpression, rightExpression)
);
break;
case ExpressionType.Equal:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.AreEqual, rightExpression)
);
break;
case ExpressionType.NotEqual:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.AreNotEqual, rightExpression)
);
break;
case ExpressionType.GreaterThan:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.GreaterThan, rightExpression)
);
break;
case ExpressionType.GreaterThanOrEqual:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.GreaterThanOrEqualTo, rightExpression)
);
break;
case ExpressionType.LessThan:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.LessThan, rightExpression)
);
break;
case ExpressionType.LessThanOrEqual:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.LessThanOrEqualTo, rightExpression)
);
break;
default:
throw new Exception($"Unsupported binary node type '{node.NodeType}'.");
}
return(node);
}
protected override Expression VisitBinary(BinaryExpression node)
{
var left = Visit(node.Left) as LinqQueryExpression <TEntity>;
if (left == null)
{
throw new InvalidOperationException("Couldn't convert expression to SQL query expression.");
}
var right = Visit(node.Right) as LinqQueryExpression <TEntity>;
if (right == null)
{
throw new InvalidOperationException("Couldn't convert expression to SQL query expression.");
}
var leftExpression = left.QueryExpression;
var rightExpression = right.QueryExpression;
switch (node.NodeType)
{
case ExpressionType.AddChecked:
case ExpressionType.Add:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Add(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.SubtractChecked:
case ExpressionType.Subtract:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Subtract(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.MultiplyChecked:
case ExpressionType.Multiply:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Multiply(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.Divide:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Divide(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.And:
return(new LinqQueryExpression <TEntity>(
QueryExpression.And(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.ExclusiveOr:
return(new LinqQueryExpression <TEntity>(
QueryExpression.ExclusiveOr(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.Or:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Or(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.AndAlso:
return(new LinqQueryExpression <TEntity>(
QueryExpression.AndAlso(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.OrElse:
return(new LinqQueryExpression <TEntity>(
QueryExpression.OrElse(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.Equal:
return(new LinqQueryExpression <TEntity>(
QueryExpression.AreEqual(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.NotEqual:
return(new LinqQueryExpression <TEntity>(
QueryExpression.AreNotEqual(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.GreaterThan:
return(new LinqQueryExpression <TEntity>(
QueryExpression.GreaterThan(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.GreaterThanOrEqual:
return(new LinqQueryExpression <TEntity>(
QueryExpression.GreaterThanOrEqualTo(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.LessThan:
return(new LinqQueryExpression <TEntity>(
QueryExpression.LessThan(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.LessThanOrEqual:
return(new LinqQueryExpression <TEntity>(
QueryExpression.LessThanOrEqualTo(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
default:
throw new Exception($"Unsupported binary node type '{node.NodeType}'.");
}
}