private void GetColumns(MappingEntity entity, Dictionary <string, TableAlias> aliases, List <DbColumnDeclaration> columns) { foreach (var mi in this.mapping.GetMappedMembers(entity)) { if (this.mapping.IsAssociationRelationship(entity, mi) == false) { if (this.mapping.IsNestedEntity(entity, mi)) { this.GetColumns(this.mapping.GetRelatedEntity(entity, mi), aliases, columns); } else if (this.mapping.IsColumn(entity, mi)) { var name = this.mapping.GetColumnName(entity, mi); var aliasName = this.mapping.GetAlias(entity, mi); aliases.TryGetValue(aliasName, out TableAlias alias); var colType = this.GetColumnType(entity, mi); var ce = new DbColumnExpression(TypeHelper.GetMemberType(mi), colType, alias, name); var cd = new DbColumnDeclaration(name, ce, colType); columns.Add(cd); } } } }
protected override Expression VisitColumn(DbColumnExpression column) { if (this.scope != null && this.scope.TryGetValue(column, out ParameterExpression fieldReader, out int iOrdinal)) { var method = FieldReader.GetReaderMethod(column.Type); return(Expression.Call(fieldReader, method, Expression.Constant(iOrdinal))); }
protected override Expression VisitColumn(DbColumnExpression column) { if (this.map.TryGetValue(column.Alias, out TableAlias newAlias)) { return(new DbColumnExpression(column.Type, column.QueryType, newAlias, column.Name)); } return(column); }
protected DbColumnAssignment UpdateColumnAssignment(DbColumnAssignment ca, DbColumnExpression c, Expression e) { if (c != ca.Column || e != ca.Expression) { return(new DbColumnAssignment(c, e)); } return(ca); }
protected override Expression VisitColumn(DbColumnExpression column) { if (this.map.TryGetValue(column, out DbColumnExpression mapped)) { return(mapped); } return(column); }
protected override Expression VisitColumn(DbColumnExpression column) { if (this.oldAliases.Contains(column.Alias)) { return(new DbColumnExpression(column.Type, column.QueryType, this.newAlias, column.Name)); } return(column); }
private DbCommandExpression GetDependentGeneratedVariableDeclaration(MappingEntity entity, MappingTable table, List <MemberInfo> members, Expression instance, Dictionary <MemberInfo, Expression> map) { var genIdCommand = null as DbDeclarationCommand; var generatedIds = this.mapping.GetMappedMembers(entity).Where(m => this.mapping.IsPrimaryKey(entity, m) && this.mapping.IsGenerated(entity, m)).ToList(); if (generatedIds.Count > 0) { genIdCommand = this.GetGeneratedIdCommand(entity, members, map); if (members.Count == generatedIds.Count) { return(genIdCommand); } } members = members.Except(generatedIds).ToList(); var tableAlias = new TableAlias(); var tex = new DbTableExpression(tableAlias, entity, this.mapping.GetTableName(table)); var where = null as Expression; if (generatedIds.Count > 0) { where = generatedIds.Select((m, i) => this.GetMemberExpression(tex, entity, m).Equal(map[m])).Aggregate((x, y) => x.And(y)); } else { where = this.GetIdentityCheck(tex, entity, instance); } var selectAlias = new TableAlias(); var columns = new List <DbColumnDeclaration>(); var variables = new List <DbVariableDeclaration>(); foreach (var mi in members) { var col = (DbColumnExpression)this.GetMemberExpression(tex, entity, mi); columns.Add(new DbColumnDeclaration(this.mapping.GetColumnName(entity, mi), col, col.QueryType)); var vcol = new DbColumnExpression(col.Type, col.QueryType, selectAlias, col.Name); variables.Add(new DbVariableDeclaration(mi.Name, col.QueryType, vcol)); map.Add(mi, new DbVariableExpression(mi.Name, col.Type, col.QueryType)); } var genMembersCommand = new DbDeclarationCommand(variables, new DbSelectExpression(selectAlias, columns, tex, where)); if (genIdCommand != null) { return(new DbBlockCommand(genIdCommand, genMembersCommand)); } return(genMembersCommand); }
protected override Expression VisitColumn(DbColumnExpression column) { if (column.Alias != null && !this.HideColumnAliases) { this.WriteAliasName(GetAliasName(column.Alias)); this.Write("."); } this.WriteColumnName(column.Name); return(column); }
protected virtual BindResult RebindOrderings(IEnumerable <DbOrderExpression> orderings, TableAlias alias, HashSet <TableAlias> existingAliases, IEnumerable <DbColumnDeclaration> existingColumns) { var newColumns = null as List <DbColumnDeclaration>; var newOrderings = new List <DbOrderExpression>(); foreach (var ordering in orderings) { var expr = ordering.Expression; var column = expr as DbColumnExpression; if (column == null || (existingAliases != null && existingAliases.Contains(column.Alias))) { var iOrdinal = 0; foreach (var decl in existingColumns) { var declColumn = decl.Expression as DbColumnExpression; if (decl.Expression == ordering.Expression || (column != null && declColumn != null && column.Alias == declColumn.Alias && column.Name == declColumn.Name)) { expr = new DbColumnExpression(column.Type, column.QueryType, alias, decl.Name); break; } iOrdinal++; } if (expr == ordering.Expression) { if (newColumns == null) { newColumns = new List <DbColumnDeclaration>(existingColumns); existingColumns = newColumns; } var colName = column != null ? column.Name : "c" + iOrdinal; colName = newColumns.GetAvailableColumnName(colName); var colType = this.language.TypeSystem.GetColumnType(expr.Type); newColumns.Add(new DbColumnDeclaration(colName, ordering.Expression, colType)); expr = new DbColumnExpression(expr.Type, colType, alias, colName); } newOrderings.Add(new DbOrderExpression(ordering.OrderType, expr)); } } return(new BindResult(existingColumns, newOrderings)); }
protected virtual Expression VisitColumn(DbColumnExpression column) { var aliasName = this.aliasMap.TryGetValue(column.Alias, out int iAlias) ? "A" + iAlias : "A" + (column.Alias != null ? column.Alias.GetHashCode().ToString() : "") + "?"; this.Write(aliasName); this.Write("."); this.Write("Column(\""); this.Write(column.Name); this.Write("\")"); return(column); }
protected override Expression Visit(Expression expression) { if (this.candidates.Contains(expression)) { if (expression.NodeType == (ExpressionType)DbExpressionType.Column) { var column = expression as DbColumnExpression; if (this.map.TryGetValue(column, out DbColumnExpression mapped)) { return(mapped); } foreach (DbColumnDeclaration existingColumn in this.columns) { if (existingColumn.Expression is DbColumnExpression cex && cex.Alias == column.Alias && cex.Name == column.Name) { return(new DbColumnExpression(column.Type, column.QueryType, this.newAlias, existingColumn.Name)); } } if (this.existingAliases.Contains(column.Alias)) { var ordinal = this.columns.Count; var columnName = this.GetUniqueColumnName(column.Name); this.columns.Add(new DbColumnDeclaration(columnName, column, column.QueryType)); mapped = new DbColumnExpression(column.Type, column.QueryType, this.newAlias, columnName); this.map.Add(column, mapped); this.columnNames.Add(columnName); return(mapped); } return(column); } else { var columnName = this.GetNextColumnName(); var colType = this.language.TypeSystem.GetColumnType(expression.Type); this.columns.Add(new DbColumnDeclaration(columnName, expression, colType)); return(new DbColumnExpression(expression.Type, colType, this.newAlias, columnName)); } } else { return(base.Visit(expression)); } }
protected override Expression VisitSelect(DbSelectExpression select) { select = base.VisitSelect(select) as DbSelectExpression; var cols = select.Columns.OrderBy(c => c.Name).ToList(); var removed = new BitArray(select.Columns.Count); var anyRemoved = false; for (int i = 0, n = cols.Count; i < n - 1; i++) { var ci = cols[i]; var cix = ci.Expression as DbColumnExpression; var qt = cix != null ? cix.QueryType : ci.QueryType; var cxi = new DbColumnExpression(ci.Expression.Type, qt, select.Alias, ci.Name); for (int j = i + 1; j < n; j++) { if (!removed.Get(j)) { var cj = cols[j]; if (SameExpression(ci.Expression, cj.Expression)) { var cxj = new DbColumnExpression(cj.Expression.Type, qt, select.Alias, cj.Name); this.map.Add(cxj, cxi); removed.Set(j, true); anyRemoved = true; } } } } if (anyRemoved) { var newDecls = new List <DbColumnDeclaration>(); for (int i = 0, n = cols.Count; i < n; i++) { if (!removed.Get(i)) { newDecls.Add(cols[i]); } } select = select.SetColumns(newDecls); } return(select); }
protected override Expression VisitColumn(DbColumnExpression column) { if (this.map.TryGetValue(column.Alias, out Dictionary <string, Expression> nameMap)) { if (nameMap.TryGetValue(column.Name, out Expression expr)) { return(this.Visit(expr)); } throw new Exception("Reference to undefined column"); } return(column); }
protected override Expression VisitSelect(DbSelectExpression select) { select = base.VisitSelect(select) as DbSelectExpression; if (select.Skip != null) { var newSelect = select.SetSkip(null).SetTake(null); var canAddColumn = !select.IsDistinct && (select.GroupBy == null || select.GroupBy.Count == 0); if (canAddColumn == false) { newSelect = newSelect.AddRedundantSelect(this.language, new TableAlias()); } var colType = this.language.TypeSystem.GetColumnType(typeof(int)); newSelect = newSelect.AddColumn(new DbColumnDeclaration("_rownum", new DbRowNumberExpression(select.OrderBy), colType)); newSelect = newSelect.AddRedundantSelect(this.language, new TableAlias()); newSelect = newSelect.RemoveColumn(newSelect.Columns.Single(c => c.Name == "_rownum")); var newAlias = (newSelect.From as DbSelectExpression).Alias; var rnCol = new DbColumnExpression(typeof(int), colType, newAlias, "_rownum"); var where = null as Expression; if (select.Take != null) { where = new DbBetweenExpression(rnCol, Expression.Add(select.Skip, Expression.Constant(1)), Expression.Add(select.Skip, select.Take)); } else { where = rnCol.GreaterThan(select.Skip); } if (newSelect.Where != null) { where = newSelect.Where.And(where); } newSelect = newSelect.SetWhere(where); select = newSelect; } return(select); }
internal virtual DbProjectionExpression AddOuterJoinTest(DbProjectionExpression proj) { var test = this.GetOuterJoinTest(proj.Select); var select = proj.Select; var testCol = null as DbColumnExpression; foreach (var col in select.Columns) { if (test.Equals(col.Expression)) { testCol = new DbColumnExpression(test.Type, TypeSystem.GetColumnType(test.Type), select.Alias, col.Name); break; } } if (testCol == null) { testCol = test as DbColumnExpression; var colName = testCol != null ? testCol.Name : "Test"; if (colName != null) { colName = proj.Select.Columns.GetAvailableColumnName(colName); } var colType = this.TypeSystem.GetColumnType(test.Type); if (colType != null) { select = select.AddColumn(new DbColumnDeclaration(colName, test, colType)); testCol = new DbColumnExpression(test.Type, colType, select.Alias, colName); } } return(new DbProjectionExpression ( select, new DbOuterJoinedExpression(testCol, proj.Projector), proj.Aggregator )); }
private Expression GetIdentityCheck(DbTableExpression root, MappingEntity entity, Expression instance, MappingTable table) { if (this.mapping.IsExtensionTable(table)) { var keyColNames = this.mapping.GetExtensionKeyColumnNames(table).ToArray(); var relatedMembers = this.mapping.GetExtensionRelatedMembers(table).ToArray(); var where = null as Expression; for (int i = 0, n = keyColNames.Length; i < n; i++) { var relatedMember = relatedMembers[i]; var cex = new DbColumnExpression(TypeHelper.GetMemberType(relatedMember), this.GetColumnType(entity, relatedMember), root.Alias, keyColNames[n]); var nex = this.GetMemberExpression(instance, entity, relatedMember); var eq = cex.Equal(nex); where = (where != null) ? where.And(eq) : where; } return(where); } return(base.GetIdentityCheck(root, entity, instance)); }
private Expression MakeSubquery(Expression expression) { var newAlias = new TableAlias(); var aliases = DbDeclaredAliasGatherer.Gather(expression); var decls = new List <DbColumnDeclaration>(); foreach (var ta in aliases) { foreach (var col in this.columns[ta]) { var name = decls.GetAvailableColumnName(col.Name); var decl = new DbColumnDeclaration(name, col, col.QueryType); decls.Add(decl); var newCol = new DbColumnExpression(col.Type, col.QueryType, newAlias, col.Name); this.map.Add(col, newCol); } } return(new DbSelectExpression(newAlias, decls, expression, null)); }
public DbColumnAssignment(DbColumnExpression column, Expression expression) { this.Column = column; this.Expression = expression; }
protected override Expression VisitColumn(DbColumnExpression column) { MarkColumnAsUsed(column.Alias, column.Name); return(column); }
internal override DbProjectionExpression GetQueryExpression(MappingEntity entity) { var tables = this.mapping.GetTables(entity); if (tables.Count <= 1) { return(base.GetQueryExpression(entity)); } var aliases = new Dictionary <string, TableAlias>(); var rootTable = tables.Single(ta => !this.mapping.IsExtensionTable(ta)); var tex = new DbTableExpression(new TableAlias(), entity, this.mapping.GetTableName(rootTable)); aliases.Add(this.mapping.GetAlias(rootTable), tex.Alias); var source = tex as Expression; foreach (var table in tables.Where(t => this.mapping.IsExtensionTable(t))) { var joinedTableAlias = new TableAlias(); var extensionAlias = this.mapping.GetAlias(table); aliases.Add(extensionAlias, joinedTableAlias); var keyColumns = this.mapping.GetExtensionKeyColumnNames(table).ToList(); var relatedMembers = this.mapping.GetExtensionRelatedMembers(table).ToList(); var relatedAlias = this.mapping.GetExtensionRelatedAlias(table); aliases.TryGetValue(relatedAlias, out TableAlias relatedTableAlias); var joinedTex = new DbTableExpression(joinedTableAlias, entity, this.mapping.GetTableName(table)); var cond = null as Expression; for (int i = 0, n = keyColumns.Count; i < n; i++) { var memberType = TypeHelper.GetMemberType(relatedMembers[i]); var colType = this.GetColumnType(entity, relatedMembers[i]); var relatedColumn = new DbColumnExpression(memberType, colType, relatedTableAlias, this.mapping.GetColumnName(entity, relatedMembers[i])); var joinedColumn = new DbColumnExpression(memberType, colType, joinedTableAlias, keyColumns[i]); var eq = joinedColumn.Equal(relatedColumn); cond = (cond != null) ? cond.And(eq) : eq; } source = new DbJoinExpression(JoinType.SingletonLeftOuter, source, joinedTex, cond); } var columns = new List <DbColumnDeclaration>(); this.GetColumns(entity, aliases, columns); var root = new DbSelectExpression(new TableAlias(), columns, source, null); var existingAliases = aliases.Values.ToArray(); var projector = this.GetEntityExpression(root, entity) as Expression; var selectAlias = new TableAlias(); var pc = DbColumnProjector.ProjectColumns(this.Translator.Linguist.Language, projector, null, selectAlias, root.Alias); var proj = new DbProjectionExpression ( new DbSelectExpression(selectAlias, pc.Columns, root, null), pc.Projector ); return(this.Translator.Police.ApplyPolicy(proj, entity.ElementType.GetTypeInfo()) as DbProjectionExpression); }
protected virtual bool CompareColumn(DbColumnExpression a, DbColumnExpression b) { return(this.CompareAlias(a.Alias, b.Alias) && a.Name == b.Name); }
protected override Expression VisitColumn(DbColumnExpression column) { this.columns.Add(column); return(column); }
protected virtual Expression VisitColumn(DbColumnExpression column) { return(column); }
protected override Expression VisitColumn(DbColumnExpression column) { this.aliases.Add(column.Alias); return(column); }