private static void UpdateIncludeSelectAndProcessToNodes(
IncludeNode graphNode, IDbSelect includedSelect, IModelInfoProvider infoProvider,
IDbObjectFactory dbFactory, UniqueNameGenerator nameGenerator, AbstractMethodTranslator[] addons)
{
// create temp table
var entityRef = includedSelect.GetReturnEntityRef();
var returnTable = (IDbTable)entityRef.Referee;
var newIncludedSelect = dbFactory.BuildSelect(returnTable);
newIncludedSelect.From.Alias = nameGenerator.GenerateAlias(newIncludedSelect, returnTable.TableName);
var tempTableName = TranslationConstants.TempTablePreix + nameGenerator.GenerateAlias(null, returnTable.TableName, true);
var tempTable = dbFactory.BuildTempTable(tempTableName, includedSelect);
var tempSelect = dbFactory.BuildSelect(tempTable);
tempSelect.From.Alias = nameGenerator.GenerateAlias(tempSelect, tempTable.TableName);
var joinToTemp = MakeJoin(newIncludedSelect, tempSelect, dbFactory, nameGenerator);
var joinTo = joinToTemp.To;
newIncludedSelect.Joins.Add(joinToTemp);
foreach (var pk in returnTable.PrimaryKeys)
{
var fromPkCol = dbFactory.BuildColumn(entityRef, pk.Name, pk.ValType);
includedSelect.Selection.Add(fromPkCol);
var toPkCol = dbFactory.BuildColumn(tempSelect.From, pk.Name, pk.ValType);
tempSelect.Selection.Add(toPkCol);
tempSelect.GroupBys.Add(toPkCol);
toPkCol = dbFactory.BuildColumn(joinTo, pk.Name, pk.ValType);
var binary = dbFactory.BuildBinary(fromPkCol, DbOperator.Equal, toPkCol);
joinToTemp.Condition = joinToTemp.Condition.UpdateBinary(binary, dbFactory);
}
var orderCol = dbFactory.BuildColumn(tempSelect.From, tempTable.RowNumberColumnName, typeof(int));
tempSelect.Selection.Add(orderCol);
orderCol = dbFactory.BuildColumn(joinTo, tempTable.RowNumberColumnName, typeof(int));
newIncludedSelect.OrderBys.Add(orderCol);
graphNode.Select = newIncludedSelect;
graphNode.TempTable = tempTable;
foreach (var toNode in graphNode.ToNodes)
{
TranslateGraphNode(toNode, infoProvider, dbFactory, nameGenerator, addons);
}
}
public static IDbSelect Map(
IDbSelect dbSelect, Type returnType,
IModelInfoProvider infoProvider, IDbObjectFactory dbFactory, UniqueNameGenerator nameGenerator)
{
// If the select returns specified columns, it means there is a constructor in Select,
// e.g (.Select(d => new { A = d.ABC }))
// In this case we do not need to add alias to the end result as where will be one in the select
if (dbSelect.Selection.Any(s => !(s is IDbRefColumn)))
{
return(dbSelect);
}
var entityInfo = infoProvider.FindEntityInfo(returnType);
if (!entityInfo.RequirePropertyNameMapping())
{
return(dbSelect);
}
var alias = nameGenerator.GenerateAlias(dbSelect, TranslationConstants.SubSelectPrefix, true);
var newSelectRef = dbFactory.BuildRef(dbSelect, alias);
var newSelect = dbFactory.BuildSelect(newSelectRef);
foreach (var fieldInfo in entityInfo.Columns)
{
var column = dbFactory.BuildColumn(
newSelectRef, fieldInfo.DbName, fieldInfo.ValType, fieldInfo.PropertyName);
newSelect.Selection.Add(column);
}
return(newSelect);
}
private static IDbJoin MakeJoin(IDbSelect ownerSelect, IDbObject tempSelect, IDbObjectFactory dbFactory, UniqueNameGenerator nameGenerator)
{
var joinAlias = nameGenerator.GenerateAlias(ownerSelect, TranslationConstants.SubSelectPrefix);
var joinTo = dbFactory.BuildRef(tempSelect, joinAlias);
return(dbFactory.BuildJoin(joinTo, ownerSelect));
}
protected override Expression VisitConstant(ConstantExpression c)
{
var entityInfo = _infoProvider.FindEntityInfo(c.Type);
if (entityInfo != null)
{
var dbTable = _dbFactory.BuildTable(entityInfo);
var dbRef = _dbFactory.BuildRef(dbTable);
var dbSelect = _dbFactory.BuildSelect(dbRef);
dbRef.Alias = _nameGenerator.GenerateAlias(dbSelect, dbTable.TableName);
_state.ResultStack.Push(dbSelect);
}
else if (!c.Type.IsAnonymouse())
{
var dbConstant = _dbFactory.BuildConstant(c.Value, true);
_state.ResultStack.Push(dbConstant);
}
return(c);
}
private static void UpdateFromNodeTempTable(
IncludeNode fromNode, IDbObject dbObject, IDbSelect includedSelect,
IDbObjectFactory dbFactory, UniqueNameGenerator nameGenerator)
{
var fromSelect = fromNode.Select;
var dbJoin = fromSelect.Joins.Single(
j => dbObject is DbReference ? ReferenceEquals(j.To, dbObject) : ReferenceEquals(j.To.Referee, dbObject));
// remove the join to included relation from fromSelect
fromSelect.Joins.Remove(dbJoin);
if (dbObject is IDbSelect)
{
var refCol = includedSelect.Selection.Single(c => c is IDbRefColumn);
includedSelect.Selection.Remove(refCol);
}
var keys = dbJoin.Condition.GetDbObjects <IDbColumn>().ToArray();
var fromKeys = keys.Where(c => !ReferenceEquals(c.Ref, dbJoin.To)).ToArray();
var toKeys = keys.Where(c => ReferenceEquals(c.Ref, dbJoin.To)).ToArray();
var tempTable = fromNode.TempTable;
var sourceSelect = tempTable.SourceSelect;
var fromRef = sourceSelect.GetReturnEntityRef();
var returnRef = includedSelect.GetReturnEntityRef();
var tempSelect = dbFactory.BuildSelect(tempTable);
tempSelect.From.Alias = nameGenerator.GenerateAlias(tempSelect, tempTable.TableName);
var joinToTemp = MakeJoin(includedSelect, tempSelect, dbFactory, nameGenerator);
includedSelect.Joins.Add(joinToTemp);
for (var i = 0; i < fromKeys.Length; i++)
{
var fromKey = fromKeys[i];
var toKey = toKeys[i];
var fromPkCol = dbFactory.BuildColumn(fromRef, fromKey.Name, fromKey.ValType);
sourceSelect.Selection.Add(fromPkCol);
var tempPkCol = dbFactory.BuildColumn(tempSelect.From, fromKey.Name, fromKey.ValType);
tempSelect.Selection.Add(tempPkCol);
tempSelect.GroupBys.Add(tempPkCol);
if (dbObject is IDbSelect)
{
var key = toKey;
toKey = (IDbColumn)includedSelect.Selection.Single(c => c.GetAliasOrName() == key.GetNameOrAlias());
includedSelect.Selection.Remove(toKey);
includedSelect.GroupBys.Remove(toKey);
}
fromPkCol = dbFactory.BuildColumn(joinToTemp.To, fromKey.Name, fromKey.ValType);
var toPkCol = dbFactory.BuildColumn(returnRef, toKey.Name, toKey.ValType);
var binary = dbFactory.BuildBinary(toPkCol, DbOperator.Equal, fromPkCol);
joinToTemp.Condition = joinToTemp.Condition.UpdateBinary(binary, dbFactory);
}
}
