/// <summary>
/// Visits a COUNT expression
/// </summary>
/// <param name="countExpression"></param>
protected virtual void VisitCountExpression(CountExpression countExpression)
{
if (countExpression != null)
{
VisitConditionBasedListExpression(countExpression);
}
}
private string Base(Expression exp)
{
var cached = (CachedExpression)exp;
if (cached.Sql != null)
{
return(cached.Sql);
}
cached.Sql = exp switch
{
UnionExpression e => Union(e),
SelectExpression e => Select(e),
WhereExpression e => Where(e),
MaxExpression e => Max(e),
MinExpression e => Min(e),
SumExpression e => Sum(e),
CountExpression e => Count(e),
TakeExpression e => Take(e),
SkipExpression e => Skip(e),
FirstExpression e => First(e),
DistinctExpression e => Distinct(e),
OrderByExpression e => OrderBy(e),
OrderByDescendingExpression e => OrderByDescending(e),
_ => throw new InvalidEnumArgumentException()
};
return(cached.Sql);
}
public virtual Expression VisitCountExpression(CountExpression countExpression)
{
Check.NotNull(countExpression, "countExpression");
_sql.Append("COUNT(*)");
return(countExpression);
}
public virtual Expression VisitCount(CountExpression countExpression)
{
Check.NotNull(countExpression, nameof(countExpression));
_relationalCommandBuilder.Append("COUNT(*)");
return(countExpression);
}
protected QueryExpression ParseCountOrField(FieldChainRequirements chainRequirements)
{
CountExpression count = TryParseCount();
if (count != null)
{
return(count);
}
return(ParseFieldChain(chainRequirements, "Count function or field name expected."));
}
public override Expression VisitCountExpression(CountExpression countExpression)
{
Check.NotNull(countExpression, nameof(countExpression));
if (countExpression.Type == typeof(long))
{
Sql.Append("COUNT_BIG(*)");
return(countExpression);
}
return(base.VisitCountExpression(countExpression));
}
public override Expression VisitCount(CountExpression countExpression)
{
Check.NotNull(countExpression, nameof(countExpression));
if (countExpression.Type != typeof(long))
{
return(base.VisitCount(countExpression));
}
Sql.Append("CAST(COUNT(*) AS bigint)");
return(countExpression);
}
public override Expression VisitCount(CountExpression expression, TArgument argument)
{
var collectionExpression = Visit(expression.TargetCollection, argument);
var propertyExpression = TryGetCollectionCount(collectionExpression);
if (propertyExpression == null)
{
throw new InvalidOperationException($"Field '{expression.TargetCollection}' must be a collection.");
}
return(propertyExpression);
}
protected QueryExpression ParseCountOrConstantOrNullOrField(FieldChainRequirements chainRequirements)
{
CountExpression count = TryParseCount();
if (count != null)
{
return(count);
}
IdentifierExpression constantOrNull = TryParseConstantOrNull();
if (constantOrNull != null)
{
return(constantOrNull);
}
return(ParseFieldChain(chainRequirements, "Count function, value between quotes, null or field name expected."));
}
public override Expression VisitCount(CountExpression countExpression)
{
Check.NotNull(countExpression, nameof(countExpression));
if (countExpression.Type == typeof(long))
{
Sql.Append("COUNT(*)");
}
else if (countExpression.Type == typeof(int))
{
Sql.Append("CAST(COUNT(*) AS UNSIGNED)");
}
else
{
throw new NotSupportedException($"Count expression with type {countExpression.Type} not supported");
}
return(countExpression);
}
private Expression GetFunction(Expression parent, string token)
{
FunctionExpression result = null;
var arguments = new List <Expression>();
string functionName = "";
using (Tokenizer.ExpectBrackets())
{
functionName = token;
if (!Tokenizer.IsNextToken(Constants.CloseBracket))
{
do
{
if (String.Compare(functionName, Constants.Count, true) == 0)
{
var distinct = Tokenizer.TokenEquals(Constants.Distinct);
result = new CountExpression(parent, distinct);
}
arguments.Add(ReadExpression(parent));
if (Tokenizer.TokenEquals(Constants.As))
{
if (!String.Equals(functionName, Constants.Cast, StringComparison.InvariantCultureIgnoreCase))
{
throw new SyntaxException("AS is allowed only within a CAST expression");
}
result = new CastExpression(parent, GetProcessType());
break;
}
}while (Tokenizer.TokenEquals(Constants.Comma));
}
}
result = result ?? new FunctionExpression(parent)
{
Name = functionName
};
result.Arguments = arguments;
return(result);
}
public override Expression VisitCountExpression(CountExpression countExpression)
{
Check.NotNull(countExpression, nameof(countExpression));
// Note that PostgreSQL COUNT(*) is BIGINT (64-bit). For 32-bit Count() expressions we cast.
if (countExpression.Type == typeof(long))
{
Sql.Append("COUNT(*)");
}
else if (countExpression.Type == typeof(int))
{
Sql.Append("COUNT(*)::INT4");
}
else
{
throw new NotSupportedException(string.Format("Count expression with type {0} not supported", countExpression.Type));
}
return(countExpression);
}
protected SortElementExpression ParseSortElement()
{
bool isAscending = true;
if (TokenStack.TryPeek(out Token nextToken) && nextToken.Kind == TokenKind.Minus)
{
TokenStack.Pop();
isAscending = false;
}
CountExpression count = TryParseCount();
if (count != null)
{
return(new SortElementExpression(count, isAscending));
}
var errorMessage = isAscending ? "-, count function or field name expected." : "Count function or field name expected.";
ResourceFieldChainExpression targetAttribute = ParseFieldChain(FieldChainRequirements.EndsInAttribute, errorMessage);
return(new SortElementExpression(targetAttribute, isAscending));
}
protected virtual Expression VisitCount(CountExpression node)
{
Append("COUNT(1)");
return(node);
}
public virtual Expression VisitCountExpression(CountExpression countExpression)
{
_sql.Append("COUNT(*)");
return(countExpression);
}
protected virtual Expression VisitCount(CountExpression node)
{
Append("COUNT(1)");
return node;
}
