public override NLinq.Expressions.Expression Visit(NLinq.Expressions.BinaryExpression item)
{
switch (item.Type)
{
case BinaryExpressionType.And:
case BinaryExpressionType.Or:
return base.Visit(item);
default:
string oldIdentifier = currentIdentifier;
currentIdentifier = null;
Visit(item.LeftExpression);
if (currentIdentifier == null)
Visit(item.RightExpression);
BinaryExpression constraint;
if (!identifiers.TryGetValue(currentIdentifier, out constraint))
identifiers[currentIdentifier] = item;
else
identifiers[currentIdentifier] = new BinaryExpression(BinaryExpressionType.And, constraint, item);
return item;
}
}
public UpdateStatement Update(Evaluant.Uss.SqlMapper.Mapping.Entity entity)
{
UpdateStatement update = new UpdateStatement() { From = new SqlExpressions.FromClause(new TableSourceExpression(null, entity.Table)) };
foreach (var item in entity.Ids.Values)
{
var idConstraint = new BinaryExpression(BinaryExpressionType.Equal, new ColumnExpression(null, item.ColumnName), new DbParameter(item.Name, item.DbType, System.Data.ParameterDirection.Input));
if (update.Where == null)
update.Where = new WhereClause(idConstraint);
else
update.Where.Expression = new BinaryExpression(BinaryExpressionType.And, update.Where.Expression, idConstraint);
}
return update;
}
private void BuildConstraint(Evaluant.Uss.SqlMapper.Mapping.Reference rm, out TableAlias firstAlias)
{
BinaryExpression on = null;
JoinedTableExpression join = null;
TableAlias lastAlias = null;
firstAlias = new LazyTableAlias(rm.Rules[0].ParentTable);
foreach (Mapping.Rule rule in rm.Rules)
{
JoinedTableExpression tempJoin = new JoinedTableExpression(new TableSourceExpression(lastAlias ?? firstAlias, rule.ParentTable), new TableSourceExpression(new TableAlias(), rule.ChildTable));
BinaryExpression tempOn = null;
for (int i = 0; i < rule.ParentFields.Count; i++)
{
Field parentField = rule.ParentFields[i];
Field childField = rule.ChildFields[i];
BinaryExpression localOn = new BinaryExpression(BinaryExpressionType.Equal,
new ColumnExpression(tempJoin.LeftTable.Alias, parentField.ColumnName),
new ColumnExpression(tempJoin.RightTable.Alias, childField.ColumnName));
if (tempOn == null)
tempOn = localOn;
else
tempOn = new BinaryExpression(BinaryExpressionType.And, tempOn, localOn);
}
tempJoin.On = tempOn;
if (join != null)
tempJoin.LeftTable = join;
lastAlias = tempJoin.RightTable.Alias;
join = tempJoin;
if (on == null)
on = tempOn;
else
on = new BinaryExpression(BinaryExpressionType.And, on, tempOn);
}
joins[rm] = join;
ons[rm] = on;
}
public IDbStatement Create(Mapping.Reference reference, ValuedParameter idParameter)
{
//Case of single rule and FK is in the child table
if (reference.Model.Cardinality.IsOne && reference.Model.Cardinality is Cardinality.ToMany)
{
Mapping.Rule rule = reference.Rules[0];
TableAlias alias = null;
UpdateStatement update = new UpdateStatement() { From = new Evaluant.Uss.SqlExpressions.FromClause(new TableSourceExpression(alias, rule.ChildTable)) };
foreach (Field field in rule.ChildFields)
update.Set.Add(new ColumnExpression(alias, field.ColumnName), new Evaluant.Uss.SqlExpressions.DbParameter(field.ColumnName.Text, field.DbType, System.Data.ParameterDirection.Input));
BinaryExpression constraint = null;
foreach (Mapping.Attribute attribute in reference.Target.Ids.Values)
{
Field field = attribute.Field;
BinaryExpression fieldConstraint = new BinaryExpression(BinaryExpressionType.Equal, new ColumnExpression(alias, field.ColumnName), new SqlExpressions.DbParameter(field.ColumnName.Text, field.DbType, System.Data.ParameterDirection.Input));
if (constraint == null)
constraint = fieldConstraint;
else
constraint = new BinaryExpression(BinaryExpressionType.And, constraint, fieldConstraint);
}
update.Where = new WhereClause(constraint);
return update;
}
//Case of single rule and FK is in the parent table
if (reference.Model.Cardinality.IsMany && reference.Model.Cardinality is Cardinality.ToOne)
{
Mapping.Rule rule = reference.Rules[0];
TableAlias alias = null;
UpdateStatement update = new UpdateStatement() { From = new Evaluant.Uss.SqlExpressions.FromClause(new TableSourceExpression(alias, rule.ParentTable)) };
foreach (Field field in rule.ParentFields)
update.Set.Add(new ColumnExpression(alias, field.ColumnName), new Evaluant.Uss.SqlExpressions.DbParameter(field.ColumnName.Text, field.DbType, System.Data.ParameterDirection.Input));
BinaryExpression constraint = null;
foreach (Mapping.Attribute attribute in reference.Parent.Ids.Values)
{
Field field = attribute.Field;
BinaryExpression fieldConstraint = new BinaryExpression(BinaryExpressionType.Equal, new ColumnExpression(alias, field.ColumnName), new SqlExpressions.DbParameter(field.ColumnName.Text, field.DbType, System.Data.ParameterDirection.Input));
if (constraint == null)
constraint = fieldConstraint;
else
constraint = new BinaryExpression(BinaryExpressionType.And, constraint, fieldConstraint);
}
update.Where = new WhereClause(constraint);
return update;
}
//Case of 2 rules with an index table
if (reference.Model.Cardinality.IsMany && reference.Model.Cardinality is Cardinality.ToMany)
{
TableAlias alias = null;
Table indexTable = reference.Rules[0].ChildTable;
Dictionary<ColumnExpression, Expression> values = new Dictionary<ColumnExpression, Expression>();
InsertStatement insert = new InsertStatement(new TableSourceExpression(alias, indexTable), values);
foreach (Mapping.Rule rule in reference.Rules)
{
if (rule.ParentTable == indexTable)
{
foreach (Field field in rule.ParentFields)
values.Add(new ColumnExpression(alias, field.ColumnName), new SqlExpressions.DbParameter(field.ColumnName.Text, field.DbType, System.Data.ParameterDirection.Input));
}
if (rule.ChildTable == indexTable)
{
foreach (Field field in rule.ChildFields)
{
if (field.IsIdentity)
values.Add(new ColumnExpression(alias, field.ColumnName), new LazyParameter(field.ColumnName.Text, idParameter, System.Data.ParameterDirection.Input));
else
values.Add(new ColumnExpression(alias, field.ColumnName), new SqlExpressions.DbParameter(field.ColumnName.Text, field.DbType, System.Data.ParameterDirection.Input));
}
}
}
return insert;
}
throw new NotImplementedException();
}
public NQuery Where(object left, object right, BinaryExpressionType type)
{
Expression e = new BinaryExpression(type, new ValueExpression(left, Convert.GetTypeCode(left)), new ValueExpression(right, Convert.GetTypeCode(right)));
return new NQuery(this, e);
}
