internal override void CreateLifetimeConditions(DmlfCommandBase cmd, string targetEntityAlias, TargetEntitySqlModel targetEntityModel)
{
cmd.AddAndCondition(new DmlfIsNullCondition
{
Expr = DmlfColumnRefExpression.Create(targetEntityAlias, ValidToColumn),
});
}
protected static bool GetCondition(DmlfCommandBase cmd, ChangeSetItem item, ChangeSetCondition cond, DatabaseInfo db)
{
var source = new DmlfSource
{
Alias = "basetbl",
LinkedInfo = item.LinkedInfo,
TableOrView = item.TargetTable,
};
var colref = cmd.SingleFrom.GetColumnRef(source, item.TargetTable, StructuredIdentifier.Parse(cond.Column), db, DmlfJoinType.Inner);
if (colref == null) return false;
//var table = db.FindTable(item.TargetTable);
//if (table == null) return false;
//var column = table.FindColumn(cond.Column);
//if (column == null) return false;
var colexpr = new DmlfColumnRefExpression
{
Column = colref
};
var column = colref.FindSourceColumn(db);
cmd.AddAndCondition(FilterParser.FilterParser.ParseFilterExpression(column != null ? column.CommonType : new DbTypeString(), colexpr, cond.Expression));
return true;
}
protected static bool GetConditions(DmlfCommandBase cmd, ChangeSetItem item, List<ChangeSetCondition> conditions, DatabaseInfo db)
{
foreach (var cond in conditions)
{
if (!GetCondition(cmd, item, cond, db)) return false;
}
return true;
}
internal override void CreateReliveConditions(DmlfCommandBase cmd, string targetEntityAlias, TargetEntitySqlModel targetEntityModel)
{
if (!String.IsNullOrEmpty(DeletedDateColumn))
{
cmd.AddAndCondition(new DmlfIsNotNullCondition
{
Expr = DmlfColumnRefExpression.Create(targetEntityAlias, DeletedDateColumn),
});
}
if (!String.IsNullOrEmpty(IsDeletedColumn))
{
cmd.AddAndCondition(new DmlfEqualCondition
{
LeftExpr = DmlfColumnRefExpression.Create(targetEntityAlias, DeletedDateColumn),
RightExpr = new DmlfLiteralExpression { Value = 1 },
});
}
}
public void AddReferenceJoins(DmlfCommandBase command)
{
foreach (var qitem in _queue)
{
var relation = new DmlfRelation
{
JoinType = DmlfJoinType.Inner,
Reference = new DmlfSource
{
Alias = qitem.RefAlias,
TableOrView = qitem.RefEntity.TargetTable,
},
};
foreach (var col in qitem.BaseEntity.TargetColumns)
{
if (col.UnderlyingReference != qitem.Fk) continue;
var refColumn = new DmlfColumnRefExpression
{
Column = new DmlfColumnRef
{
Source = new DmlfSource { Alias = qitem.RefAlias },
ColumnName = col.RefColumnName,
}
};
relation.Conditions.Add(new DmlfEqualCondition
{
LeftExpr = col.CreateTargetExpression(qitem.BaseAlias),
RightExpr = refColumn,
CollateSpec = col.UseCollate(qitem.BaseEntity.SourceJoinModel) ? "DATABASE_DEFAULT" : null,
});
}
command.SingleFrom.Relations.Add(relation);
qitem.RefEntity.CreateLifetimeConditions(command, qitem.RefAlias);
qitem.RefEntity.CreateRestrictionCondition(command, qitem.RefAlias, false);
}
}
internal virtual void CreateReliveConditions(DmlfCommandBase cmd, string targetEntityAlias, TargetEntitySqlModel targetEntityModel)
{
}
internal void CreateLifetimeConditions(DmlfCommandBase res, string targetEntityAlias)
{
_dbsh.LifetimeHandler.CreateLifetimeConditions(res, targetEntityAlias, this);
}
private void CreateReferenceRestrictionsCodition(DmlfCommandBase res, string targetEntityAlias)
{
var builder = new ReferenceRestrictionJoinBuilder();
builder.FindReferences(this, "target");
builder.AddReferenceJoins(res);
}
internal void CreateRestrictionCondition(DmlfCommandBase cmd, string targetEntityAlias, bool includeReferenceRestrictions = true)
{
CreateTargetColumsnCondition(cmd, targetEntityAlias, x => x.IsRestriction && (includeReferenceRestrictions || !x.IsReference));
}
private void CreateKeyCondition(DmlfCommandBase cmd, string targetEntityAlias)
{
CreateTargetColumsnCondition(cmd, targetEntityAlias, x => x.IsKey || x.IsRestriction);
}
private void CreateTargetColumsnCondition(DmlfCommandBase cmd, string targetEntityAlias, Func<TargetColumnSqlModelBase, bool> useThisColumns)
{
foreach (var column in TargetColumns.Where(useThisColumns))
{
var cond = new DmlfEqualCondition
{
// target columns
LeftExpr = column.CreateTargetExpression(targetEntityAlias),
// source column
RightExpr = column.CreateSourceExpression(SourceJoinModel, false),
CollateSpec = column.UseCollate(SourceJoinModel) ? "DATABASE_DEFAULT" : null,
};
cmd.AddAndCondition(cond);
}
}
private void CreateNotNullConditions(DmlfCommandBase cmd)
{
foreach (var column in TargetColumns.Where(x => x.IsKey || (x.Info?.NotNull ?? false)))
{
var cond = new DmlfIsNotNullCondition
{
Expr = column.CreateSourceExpression(SourceJoinModel, false),
};
cmd.AddAndCondition(cond);
}
}
private void CreateFilterConditions(DmlfCommandBase cmd)
{
foreach(var col in SourceJoinModel.Columns.Values)
{
var colFilterCondition = col.FilterCondition;
// process additional condition
var additional = _dbsh.AdditionalFilters.FirstOrDefault(x => x.Column == col.Alias);
if (additional != null)
{
var type = SourceColumnSqlModel.DetectFilterType(additional.FilterType, col.DbshColumns);
var entity = col.Entities.First();
var expr = new DmlfColumnRefExpression
{
Column = new DmlfColumnRef
{
ColumnName = entity.GetColumnName(col.Alias),
Source = entity.QuerySource,
}
};
var additionalCondition = FilterParser.ParseFilterExpression(type, expr, additional.Filter);
if (colFilterCondition != null)
{
var andCondition = new DmlfAndCondition();
andCondition.Conditions.Add(additionalCondition);
andCondition.Conditions.Add(colFilterCondition);
colFilterCondition = andCondition;
}
else
{
colFilterCondition = additionalCondition;
}
}
if (colFilterCondition != null)
{
var orCond = new DmlfOrCondition();
if (col.Entities.Count == 1)
{
var entity = col.Entities.Single();
if (entity.SingleKeyColumnNameOrAlias != null)
{
var expr = new DmlfColumnRefExpression
{
Column = new DmlfColumnRef
{
ColumnName = entity.GetColumnName(entity.SingleKeyColumnNameOrAlias),
Source = entity.QuerySource,
}
};
orCond.Conditions.Add(new DmlfIsNullCondition
{
Expr = expr,
});
}
}
if (orCond.Conditions.Any())
{
orCond.Conditions.Add(colFilterCondition);
cmd.AddAndCondition(orCond);
}
else
{
cmd.AddAndCondition(colFilterCondition);
}
}
}
}
