public void WalkThroughTest()
{
var tUser = Tables.User();
var tCustomer = Tables.Customer();
var e = Select(tUser.UserId, tUser.FirstName, tCustomer.CustomerId)
.From(tUser)
.InnerJoin(tCustomer, on: tCustomer.UserId == tUser.UserId)
.Done();
string expected = "0ExprQuerySpecification,1Int32TableColumn,2ExprTableAlias,3ExprAliasGuid," +
"2ExprColumnName,1StringTableColumn,2ExprTableAlias,3ExprAliasGuid," +
"2ExprColumnName,1Int32TableColumn,2ExprTableAlias,3ExprAliasGuid,2ExprColumnName," +
"1ExprJoinedTable,2User,3ExprTableFullName,4ExprDbSchema,5ExprSchemaName," +
"4ExprTableName,3ExprTableAlias,4ExprAliasGuid,2Customer,3ExprTableFullName," +
"4ExprDbSchema,5ExprSchemaName,4ExprTableName,3ExprTableAlias,4ExprAliasGuid," +
"2ExprBooleanEq,3NullableInt32TableColumn,4ExprTableAlias,5ExprAliasGuid," +
"4ExprColumnName,3Int32TableColumn,4ExprTableAlias,5ExprAliasGuid,4ExprColumnName,";
StringBuilder builder = new StringBuilder();
e.SyntaxTree().WalkThrough((expr, tier) =>
{
builder.Append(tier);
builder.Append(expr.GetType().Name);
builder.Append(',');
return(VisitorResult <int> .Continue(tier + 1));
}, 0);
Assert.AreEqual(expected, builder.ToString());
}
public VisitorResult <int> VisitExpr(IExpr expr, string typeTag, int ctx)
{
var newId = this._currentId;
this._buffer.Add(this._factory(newId, ctx, null, true, typeTag, null));
return(VisitorResult <int> .Continue(newId));
}
private TransformationCollection GetTransformations(VisitorResult result, List <RequireCall> flattened)
{
var trans = new TransformationCollection();
var moduleName = this.CheckForConfigPath(RelativeFileName.ToModuleName());
if (!result.RequireCalls.Any())
{
var shim = GetShim(RelativeFileName);
var deps = new List <string>();
if (shim != null)
{
deps = shim.Dependencies.Select(r => r.Dependency).ToList();
}
trans.Add(ShimFileTransformation.Create(moduleName, deps));
}
else
{
foreach (var reqCall in result.RequireCalls.Where(r => r.DependencyArrayNode != null))
{
trans.Add(NormalizeDepsTransformation.Create(reqCall));
}
// if there are no define calls but there is at least one require module call, transform that into a define call
if (!result.RequireCalls.Where(r => r.Type == RequireCallType.Define).Any())
{
if (result.RequireCalls.Where(r => r.IsModule).Any())
{
var call = result.RequireCalls.Where(r => r.IsModule).FirstOrDefault();
trans.Add(ToDefineTransformation.Create(call));
trans.Add(AddIdentifierTransformation.Create(call, moduleName));
}
//TODO: Append shimmed dependencies here too
}
else
{
var defineCall = result.RequireCalls.Where(r => r.Type == RequireCallType.Define).FirstOrDefault();
if (string.IsNullOrEmpty(defineCall.Id))
{
trans.Add(AddIdentifierTransformation.Create(defineCall, moduleName));
}
if (defineCall.DependencyArrayNode == null)
{
trans.Add(AddEmptyDepsArrayTransformation.Create(defineCall));
}
var shim = GetShim(RelativeFileName);
if (shim != null)
{
var deps = shim.Dependencies.Select(r => r.Dependency).ToList();
trans.Add(AddDepsTransformation.Create(defineCall, deps));
}
}
}
return(trans);
}
public VisitorResult <XmlWriter> VisitExpr(IExpr expr, string typeTag, XmlWriter writer)
{
if (this._root == null)
{
writer.WriteStartElement("Expr");
this._root = expr;
}
writer.WriteAttributeString("typeTag", typeTag);
return(VisitorResult <XmlWriter> .Continue(writer));
}
public void Descendants_Test(bool self)
{
var tUser = Tables.User();
var tCustomer = Tables.Customer();
var examples = new List <IExpr>();
//1
IExpr ex = Select(tUser.UserId, tUser.FirstName, tCustomer.CustomerId)
.From(tUser)
.InnerJoin(tCustomer, on: tCustomer.UserId == tUser.UserId)
.Done();
examples.Add(ex);
//2
ex = Literal(2);
examples.Add(ex);
//3
ex = Literal(2).As(tUser.UserId);
examples.Add(ex);
//4
ex = Update(tUser)
.Set(tUser.UserId, "A")
.From(tUser)
.InnerJoin(tCustomer, on: tCustomer.UserId == tUser.UserId)
.Where(tCustomer.UserId.In(1, 3, 5));
examples.Add(ex);
foreach (var e in examples)
{
var set = new List <IExpr>();
e.SyntaxTree()
.WalkThrough((expr, tier) =>
{
if (tier != 0 || self)
{
set.Add(expr);
}
return(VisitorResult <int> .Continue(tier + 1));
},
0);
var list = self ? e.SyntaxTree().DescendantsAndSelf().ToList() : e.SyntaxTree().Descendants().ToList();
CollectionAssert.AreEqual(set, list);
}
}
public TExpr?FirstOrDefault <TExpr>(Predicate <TExpr>?filter = null) where TExpr : class, IExpr
{
TExpr?result = null;
this._expr.Accept(new ExprWalker <object?>(new DefaultWalkerVisitor <object?>((e, c) =>
{
if (e is TExpr te && (filter == null || filter.Invoke(te)))
{
result = te;
return(VisitorResult <object?> .Stop(c));
}
return(VisitorResult <object?> .Continue(c));
})), null);
return(result);
}
public VisitorResult <Utf8JsonWriter> VisitExpr(IExpr expr, string typeTag, Utf8JsonWriter ctx)
{
ctx.WriteStartObject();
ctx.WriteString("$type", typeTag);
return(VisitorResult <Utf8JsonWriter> .Continue(ctx));
}
