public EntityExpression(Type type, PrimaryKeyExpression externalId, NewExpression externalPeriod, Alias tableAlias, IEnumerable <FieldBinding> bindings, IEnumerable <MixinEntityExpression> mixins, NewExpression tablePeriod, bool avoidExpandOnRetrieving)
: base(DbExpressionType.Entity, type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!type.IsEntity())
{
throw new ArgumentException("type");
}
this.Table = Schema.Current.Table(type);
this.ExternalId = externalId ?? throw new ArgumentNullException("externalId");
this.TableAlias = tableAlias;
this.Bindings = bindings.ToReadOnly();
this.Mixins = mixins.ToReadOnly();
this.ExternalPeriod = externalPeriod;
this.TablePeriod = tablePeriod;
this.AvoidExpandOnRetrieving = avoidExpandOnRetrieving;
}
public MListElementExpression(PrimaryKeyExpression rowId, EntityExpression parent, Expression order, Expression element, NewExpression systemPeriod, TableMList table, Alias alias)
: base(DbExpressionType.MListElement, typeof(MListElement <,>).MakeGenericType(parent.Type, element.Type))
{
this.RowId = rowId;
this.Parent = parent;
this.Order = order;
this.Element = element;
this.TablePeriod = systemPeriod;
this.Table = table;
this.Alias = alias;
}
internal SetOperatorExpression(SetOperator @operator, SourceWithAliasExpression left, SourceWithAliasExpression right, Alias alias)
: base(DbExpressionType.SetOperator, alias)
{
this.Operator = @operator;
this.Left = left ?? throw new ArgumentNullException(nameof(left));
this.Right = right ?? throw new ArgumentNullException(nameof(right));
}
protected internal override Expression VisitProjection(ProjectionExpression proj)
{
if (currentSource == null)
{
currentSource = WithoutOrder(proj.Select);
Expression projector = this.Visit(proj.Projector);
if (projector != proj.Projector)
{
proj = new ProjectionExpression(proj.Select, projector, proj.UniqueFunction, proj.Type);
}
currentSource = null;
return(proj);
}
else
{
HashSet <ColumnExpression> columns = ExternalColumnGatherer.Gatherer(proj, currentSource.Alias);
if (columns.Count == 0)
{
Expression projector = Visit(proj.Projector);
ConstantExpression key = Expression.Constant(0);
Type kvpType = typeof(KeyValuePair <,>).MakeGenericType(key.Type, projector.Type);
ConstructorInfo ciKVP = kvpType.GetConstructor(new[] { key.Type, projector.Type }) !;
Type projType = proj.UniqueFunction == null ? typeof(IEnumerable <>).MakeGenericType(kvpType) : kvpType;
var childProj = new ProjectionExpression(proj.Select,
Expression.New(ciKVP, key, projector), proj.UniqueFunction, projType);
return(new ChildProjectionExpression(childProj,
Expression.Constant(0), inMList != null, inMList ?? proj.Type, new LookupToken()));
}
else
{
SelectExpression external;
IEnumerable <ColumnExpression> externalColumns;
if (!IsKey(currentSource, columns))
{
Alias aliasDistinct = aliasGenerator.GetUniqueAlias(currentSource.Alias.Name + "D");
ColumnGenerator generatorDistinct = new ColumnGenerator();
List <ColumnDeclaration> columnDistinct = columns.Select(ce => generatorDistinct.MapColumn(ce)).ToList();
external = new SelectExpression(aliasDistinct, true, null, columnDistinct, currentSource, null, null, null, 0);
Dictionary <ColumnExpression, ColumnExpression> distinctReplacements = columnDistinct.ToDictionary(
cd => (ColumnExpression)cd.Expression,
cd => cd.GetReference(aliasDistinct));
proj = (ProjectionExpression)ColumnReplacer.Replace(proj, distinctReplacements);
externalColumns = distinctReplacements.Values.ToHashSet();
}
else
{
external = currentSource;
externalColumns = columns;
}
ColumnGenerator generatorSM = new ColumnGenerator();
List <ColumnDeclaration> columnsSMExternal = externalColumns.Select(ce => generatorSM.MapColumn(ce)).ToList();
List <ColumnDeclaration> columnsSMInternal = proj.Select.Columns.Select(cd => generatorSM.MapColumn(cd.GetReference(proj.Select.Alias))).ToList();
SelectExpression @internal = ExtractOrders(proj.Select, out List <OrderExpression>?innerOrders);
Alias aliasSM = aliasGenerator.GetUniqueAlias(@internal.Alias.Name + "SM");
SelectExpression selectMany = new SelectExpression(aliasSM, false, null, columnsSMExternal.Concat(columnsSMInternal),
new JoinExpression(JoinType.CrossApply,
external,
@internal, null), null, innerOrders, null, 0);
SelectExpression old = currentSource;
currentSource = WithoutOrder(selectMany);
var selectManyReplacements = selectMany.Columns.ToDictionary(
cd => (ColumnExpression)cd.Expression,
cd => cd.GetReference(aliasSM));
Expression projector = ColumnReplacer.Replace(proj.Projector, selectManyReplacements);
projector = Visit(projector);
currentSource = old;
Expression key = TupleReflection.TupleChainConstructor(columnsSMExternal.Select(cd => MakeEquatable(cd.GetReference(aliasSM))));
Type kvpType = typeof(KeyValuePair <,>).MakeGenericType(key.Type, projector.Type);
ConstructorInfo ciKVP = kvpType.GetConstructor(new[] { key.Type, projector.Type }) !;
Type projType = proj.UniqueFunction == null ? typeof(IEnumerable <>).MakeGenericType(kvpType) : kvpType;
var childProj = new ProjectionExpression(selectMany,
Expression.New(ciKVP, key, projector), proj.UniqueFunction, projType);
return(new ChildProjectionExpression(childProj,
TupleReflection.TupleChainConstructor(columns.Select(a => MakeEquatable(a))), inMList != null, inMList ?? proj.Type, new LookupToken()));
}
}
}
public SourceWithAliasExpression(DbExpressionType nodeType, Alias alias)
: base(nodeType)
{
this.Alias = alias;
}
public ColumnExpression GetReference(Alias alias)
{
return(new ColumnExpression(Expression.Type, alias, Name));
}
private ReadOnlyCollection <ColumnDeclaration> AnswerAndExpand(ReadOnlyCollection <ColumnDeclaration> columns, Alias currentAlias, Dictionary <ColumnExpression, ColumnExpression> askedColumns)
{
ColumnGenerator cg = new ColumnGenerator(columns);
foreach (var col in askedColumns.Keys.ToArray())
{
if (col.Alias == currentAlias)
{
//Expression expr = columns.SingleEx(cd => (cd.Name ?? "-") == col.Name).Expression;
//askedColumns[col] = expr is SqlConstantExpression ? expr : col;
askedColumns[col] = col;
}
else
{
ColumnExpression colExp = CurrentScope[col];
//if (expr is ColumnExpression colExp)
//{
ColumnDeclaration cd = cg.Columns.FirstOrDefault(c => c.Expression.Equals(colExp));
if (cd == null)
{
cd = cg.MapColumn(colExp);
}
askedColumns[col] = new ColumnExpression(col.Type, currentAlias, cd.Name);
//}
//else
//{
// askedColumns[col] = expr;
//}
}
}
if (columns.Count != cg.Columns.Count())
{
return(cg.Columns.ToReadOnly());
}
return(columns);
}
public AggregateRequestsExpression(Alias groupByAlias, AggregateExpression aggregate)
: base(DbExpressionType.AggregateRequest, aggregate.Type)
{
this.Aggregate = aggregate;
this.GroupByAlias = groupByAlias;
}
public SqlTableValuedFunctionExpression(ObjectName sqlFunction, Table?viewTable, Type?singleColumnType, Alias alias, IEnumerable <Expression> arguments)
: base(DbExpressionType.SqlTableValuedFunction, alias)
{
if ((viewTable == null) == (singleColumnType == null))
{
throw new ArgumentException("Either viewTable or singleColumn should be set");
}
this.SqlFunction = sqlFunction;
this.ViewTable = viewTable;
this.SingleColumnType = singleColumnType;
this.Arguments = arguments.ToReadOnly();
}
static internal ColumnExpression SingleProjection(ColumnDeclaration declaration, Alias newAlias, Type columnType)
{
return(new ColumnExpression(columnType, newAlias, declaration.Name));
}
public ColumnProjector(HashSet <Expression> candidates, Alias newAlias, bool projectTrivialColumns)
{
this.candidates = candidates;
this.newAlias = newAlias;
this.projectTrivialColumns = projectTrivialColumns;
}
internal SetOperatorExpression(SetOperator @operator, SourceWithAliasExpression left, SourceWithAliasExpression right, Alias alias)
: base(DbExpressionType.SetOperator, alias)
{
if (left == null)
{
throw new ArgumentNullException("left");
}
if (right == null)
{
throw new ArgumentNullException("right");
}
this.Operator = @operator;
this.Left = left;
this.Right = right;
}
internal TableExpression(Alias alias, ITable table, string withHint)
: base(DbExpressionType.Table, alias)
{
this.Table = table;
this.WithHint = withHint;
}
