public string Simplify(QueryParts query)
{
var co = query.ResultOperators[0];
var prefix = "SELECT COUNT(*)";
query.Selects.Clear();
query.CurrentSelectIndex = 0;
if (co is LongCountResultOperator)
{
query.AddSelectPart(query.MainFrom, "COUNT(*)", "count", typeof(long), (_, dr) => dr.GetInt64(0));
}
else
{
query.AddSelectPart(query.MainFrom, "COUNT(*)::int", "count", typeof(int), (_, dr) => dr.GetInt32(0));
prefix += "::int";
}
prefix += " FROM ";
var type = query.MainFrom.FromExpression.Type.GetGenericArguments()[0];
var isRoot = typeof(IAggregateRoot).IsAssignableFrom(type);
if (isRoot)
return prefix + @"""{0}"".""{1}""".With(type.Namespace, type.Name);
var isEvent = typeof(IDomainEvent).IsAssignableFrom(type);
if (isEvent)
return type.IsNested
? prefix + @"""{0}"".""{1}.{2}""".With(type.Namespace, type.DeclaringType.Name, type.Name)
: prefix + @"""{0}"".""{1}""".With(type.Namespace, type.Name);
var ent =
(from i in type.GetInterfaces()
where i.IsGenericType
&& i.GetGenericTypeDefinition() == typeof(ISnowflake<>)
select i.GetGenericArguments()[0])
.FirstOrDefault() ?? type;
return prefix + @"""{0}"".""{1}""".With(ent.Namespace, ent.Name);
}
public bool CanSimplify(QueryParts query)
{
var parts = query as SubqueryParts;
return parts != null
&& !parts.ShouldQueryInMemory
&& parts.ResultOperators.Count == 1
&& parts.ResultOperators[0] is AnyResultOperator;
}
public bool CanSimplify(QueryParts query)
{
var parts = query as SubqueryParts;
return parts != null
&& !parts.ShouldQueryInMemory
&& parts.ResultOperators.Count == 1
&& parts.Conditions.Count == 0 && parts.AdditionalJoins.Count == 0 && parts.Joins.Count == 0
&& parts.ResultOperators[0] is AllResultOperator;
}
public bool CanSimplify(QueryParts query)
{
var type = query.MainFrom != null ? query.MainFrom.FromExpression.Type : null;
return type != null
&& query.ResultOperators.Count == 1
&& query.Joins.Count == 0 && query.AdditionalJoins.Count == 0 && query.Conditions.Count == 0
&& (query.ResultOperators[0] is CountResultOperator
|| query.ResultOperators[0] is LongCountResultOperator)
&& type.IsGenericType
&& type.GetGenericTypeDefinition() == QueryableType
&& typeof(IEntity).IsAssignableFrom(type.GetGenericArguments()[0]);
}
public SubqueryParts(QueryParts parentQuery, bool canQueryInMemory, Expression selector, string contextName)
: base(parentQuery.Locator,
contextName,
parentQuery.ConverterFactory,
parentQuery.Simplifications,
parentQuery.ExpressionMatchers,
parentQuery.MemberMatchers,
parentQuery.ProjectionMatchers)
{
this.CanQueryInMemory = canQueryInMemory;
this.ParentQuery = parentQuery;
this.Selector = selector;
}
private string SimplifyConstantExpression(QueryParts query, SubqueryParts parts, string exp, ConstantExpression ce)
{
if (ce.Type.IsArray || ce.Value is Array)
{
var array = ((Array)ce.Value).Cast<object>().ToArray();
return FormatInQuery(exp, array, parts);
}
else if (ce.Value is IEnumerable)
{
var array = ((IEnumerable)ce.Value).Cast<object>().ToArray();
return FormatInQuery(exp, array, parts);
}
return exp + " = " + query.FormatObject(ce.Value);
}
public static SelectSubqueryData Create(QueryParts parts, SubqueryParts subquery)
{
Contract.Requires(parts != null);
Contract.Requires(subquery != null);
var selects = new List<KeyValuePair<IQuerySource, Func<object, object>>>();
foreach (var s in subquery.Selects)
{
var factory = QuerySourceConverterFactory.Create(s.QuerySource, parts);
selects.Add(new KeyValuePair<IQuerySource, Func<object, object>>(factory.QuerySource, factory.Instancer));
}
return new SelectSubqueryData(selects);
}
public string Simplify(QueryParts query)
{
var parts = query as SubqueryParts;
var containsResult = parts.ResultOperators[0] as ContainsResultOperator;
var exp = parts.GetSqlExpression(containsResult.Item);
var ce = parts.MainFrom.FromExpression as ConstantExpression;
var pe = parts.MainFrom.FromExpression as ParameterExpression;
var ma = parts.MainFrom.FromExpression as MemberExpression;
return ce != null
? SimplifyConstantExpression(query, parts, exp, ce)
: ma != null
? SimplifyMemberExpression(query, parts, exp, ma)
: exp + " = ANY(" + (pe != null ? query.ContextName + "\"" + pe.Name + "\"" : parts.GetSqlExpression(parts.MainFrom.FromExpression)) + ")";
}
public bool CanSimplify(QueryParts query)
{
var parts = query as SubqueryParts;
var me = parts != null ? parts.MainFrom.FromExpression as MemberExpression : null;
return parts != null
&& me != null
&& !parts.ShouldQueryInMemory
&& parts.ResultOperators.Count == 1
&& parts.Joins.Count == 0 && parts.AdditionalJoins.Count == 0 && parts.Conditions.Count == 0
&& (me.Expression is QuerySourceReferenceExpression
|| me.Expression is ParameterExpression)
&& me.Type.IsSupportedCollectionType()
&& (parts.ResultOperators[0] is CountResultOperator
|| parts.ResultOperators[0] is LongCountResultOperator);
}
public bool CanSimplify(QueryParts query)
{
var parts = query as SubqueryParts;
var ce = parts != null ? parts.MainFrom.FromExpression as ConstantExpression : null;
var me = parts != null ? parts.MainFrom.FromExpression as MemberExpression : null;
var pe = parts != null ? parts.MainFrom.FromExpression as ParameterExpression : null;
return parts != null
&& (ce != null && ce.Type.IsSupportedCollectionType()
|| me != null
|| pe != null)
&& !parts.ShouldQueryInMemory
&& parts.ResultOperators.Count == 1
&& parts.Joins.Count == 0 && parts.AdditionalJoins.Count == 0 && parts.Conditions.Count == 0
&& parts.ResultOperators[0] is ContainsResultOperator;
}
public string Simplify(QueryParts query)
{
var parts = query as SubqueryParts;
var me = parts.MainFrom.FromExpression as MemberExpression;
if (me != null && parts.Conditions.Count == 0)
{
var qse = me.Expression as QuerySourceReferenceExpression;
if (qse != null)
return
"EXISTS (SELECT * FROM UNNEST((\"{0}\").\"{1}\"))".With(
qse.ReferencedQuerySource.ItemName,
me.Member.Name);
}
return "EXISTS (SELECT * {0} {1})".With(parts.GetFromPart(), parts.GetWherePart());
}
public string Simplify(QueryParts query)
{
var parts = query as SubqueryParts;
var me = parts.MainFrom.FromExpression as MemberExpression;
var qsre = me.Expression as QuerySourceReferenceExpression;
var pe = me.Expression as ParameterExpression;
if (me.Type == typeof(byte[]))
{
return @"COALESCE(octet_length(({2}""{0}"").""{1}""), 0)".With(
qsre != null ? qsre.ReferencedQuerySource.ItemName : pe.Name,
me.Member.Name,
pe != null ? query.ContextName : string.Empty);
}
return @"COALESCE(array_upper(({2}""{0}"").""{1}"", 1), 0)".With(
qsre != null ? qsre.ReferencedQuerySource.ItemName : pe.Name,
me.Member.Name,
pe != null ? query.ContextName : string.Empty);
}
public string Simplify(QueryParts query)
{
var parts = query as SubqueryParts;
var aro = parts.ResultOperators[0] as AllResultOperator;
return " NOT EXISTS (SELECT * {0} WHERE NOT ({1}))".With(parts.GetFromPart(), parts.GetSqlExpression(aro.Predicate));
}
private string SimplifyMemberExpression(QueryParts query, SubqueryParts parts, string exp, MemberExpression ma)
{
return exp + " IN (SELECT " + query.GetSqlExpression(parts.Selector)
+ " FROM unnest(" + query.GetSqlExpression(ma) + ") \"" + query.MainFrom.ItemName + "\")";
}
public static SubqueryParts ParseSubquery(QueryModel queryModel, QueryParts parentQuery, bool canQueryInMemory, string contextName)
{
var visitor = new SubqueryGeneratorQueryModelVisitor(parentQuery, canQueryInMemory, queryModel.SelectClause.Selector, contextName);
visitor.VisitQueryModel(queryModel);
return visitor.QueryParts;
}
public static SubqueryParts ParseSubquery(QueryModel queryModel, QueryParts parentQuery, bool canQueryInMemory)
{
return ParseSubquery(queryModel, parentQuery, canQueryInMemory, parentQuery.ContextName);
}
public static SubqueryParts ParseSubquery(QueryModel queryModel, QueryParts parentQuery)
{
return ParseSubquery(queryModel, parentQuery, false, parentQuery.ContextName);
}
private SubqueryGeneratorQueryModelVisitor(QueryParts parentQuery, bool canQueryInMemory, Expression selector, string contextName)
{
QueryParts = new SubqueryParts(parentQuery, canQueryInMemory, selector, contextName);
}
public SubqueryParts(QueryParts parentQuery, Expression selector, string contextName)
: this(parentQuery, false, selector, contextName)
{
}
public SubqueryParts(QueryParts parentQuery, Expression selector, string contextName)
: this(parentQuery, false, selector, contextName)
{
}
