public override void Visit(AccessMethodNode node)
{
if (node.IsAggregateMethod)
{
Nodes.Pop();
var wordNode = node.Arguments.Args[0] as WordNode;
var accessGroup = new AccessColumnNode("none", string.Empty, typeof(Group), TextSpan.Empty);
var args = new List <Node> {
accessGroup, wordNode
};
args.AddRange(node.Arguments.Args.Skip(1));
var extractFromGroup = new AccessMethodNode(
new FunctionToken(node.Method.Name, TextSpan.Empty),
new ArgsListNode(args.ToArray()), node.ExtraAggregateArguments, node.CanSkipInjectSource, node.Method, node.Alias);
Nodes.Push(extractFromGroup);
}
else if (_fields.Select(f => f.Expression.ToString()).Contains(node.ToString()))
{
Nodes.Push(new AccessColumnNode(node.ToString(), string.Empty, node.ReturnType, TextSpan.Empty));
}
else
{
base.Visit(node);
}
}
public override void Visit(AccessMethodNode node)
{
if (node.IsAggregateMethod)
{
Nodes.Pop();
var wordNode = node.Arguments.Args[0] as WordNode;
Nodes.Push(new AccessColumnNode(wordNode.Value, string.Empty, node.ReturnType, TextSpan.Empty));
}
else if (_fields.Select(f => f.Expression.ToString()).Contains(node.ToString()))
{
Nodes.Push(new AccessColumnNode(node.ToString(), string.Empty, node.ReturnType, TextSpan.Empty));
}
else
{
base.Visit(node);
}
}
private void VisitAccessMethod(
AccessMethodNode node,
Func <FunctionToken, Node, ArgsListNode, MethodInfo, string, bool, AccessMethodNode> func)
{
var args = Nodes.Pop() as ArgsListNode;
var groupArgs = new List <Type> {
typeof(string)
};
groupArgs.AddRange(args.Args.Skip(1).Select(f => f.ReturnType));
var alias = !string.IsNullOrEmpty(node.Alias) ? node.Alias : _identifier;
var tableSymbol = _currentScope.ScopeSymbolTable.GetSymbol <TableSymbol>(alias);
var schemaTablePair = tableSymbol.GetTableByAlias(alias);
var canSkipInjectSource = false;
if (!schemaTablePair.Schema.TryResolveAggreationMethod(node.Name, groupArgs.ToArray(), out var method))
{
if (!schemaTablePair.Schema.TryResolveMethod(node.Name, args.Args.Select(f => f.ReturnType).ToArray(), out method))
{
if (!schemaTablePair.Schema.TryResolveRawMethod(node.Name, args.Args.Select(f => f.ReturnType).ToArray(), out method))
{
var types = args.Args.Length > 0
? args.Args.Select(f => f.ReturnType.ToString()).Aggregate((a, b) => a + ", " + b)
: string.Empty;
throw new UnresolvableMethodException($"{node.Name}({types}) cannot be resolved.");
}
canSkipInjectSource = true;
}
}
var isAggregateMethod = method.GetCustomAttribute <AggregationMethodAttribute>() != null;
AccessMethodNode accessMethod;
if (isAggregateMethod)
{
accessMethod = func(node.FToken, args, node.ExtraAggregateArguments, method, alias, false);
var identifier = accessMethod.ToString();
var newArgs = new List <Node> {
new WordNode(identifier)
};
newArgs.AddRange(args.Args.Skip(1));
var newSetArgs = new List <Node> {
new WordNode(identifier)
};
newSetArgs.AddRange(args.Args);
var setMethodName = $"Set{method.Name}";
var argTypes = newSetArgs.Select(f => f.ReturnType).ToArray();
if (!schemaTablePair.Schema.TryResolveAggreationMethod(
setMethodName,
argTypes,
out var setMethod))
{
var names = argTypes.Length == 0
? string.Empty
: argTypes.Select(arg => arg.Name).Aggregate((a, b) => a + ", " + b);
throw new NotSupportedException($"Cannot resolve method {setMethodName} with parameters {names}");
}
if (setMethod.IsGenericMethodDefinition)
{
var setParams = setMethod.GetParameters();
var genericArguments = setMethod.GetGenericArguments();
var genericArgumentsMap = new Dictionary <int, Type>();
var genericArgumentsDistinct = new List <Type>();
foreach (var genericArgument in genericArguments)
{
for (int i = 0; i < setParams.Length; i++)
{
var setParam = setParams[i];
if (setParam.ParameterType == genericArgument)
{
genericArgumentsMap.Add(i, genericArgument);
genericArgumentsDistinct.Add(newSetArgs.Where((arg, index) => index == i - 1).Single().ReturnType);
}
}
}
var genericArgumentsConcreteTypes = genericArgumentsDistinct.Distinct().ToArray();
method = method.MakeGenericMethod(genericArgumentsConcreteTypes);
setMethod = setMethod.MakeGenericMethod(genericArgumentsConcreteTypes);
}
var setMethodNode = func(new FunctionToken(setMethodName, TextSpan.Empty),
new ArgsListNode(newSetArgs.ToArray()), null, setMethod,
alias, false);
_refreshMethods.Add(setMethodNode);
accessMethod = func(node.FToken, new ArgsListNode(newArgs.ToArray()), null, method, alias, canSkipInjectSource);
}
else
{
accessMethod = func(node.FToken, args, new ArgsListNode(new Node[0]), method, alias, canSkipInjectSource);
}
AddAssembly(method.DeclaringType.Assembly);
AddAssembly(method.ReturnType.Assembly);
node.ChangeMethod(method);
Nodes.Push(accessMethod);
}
public virtual void Visit(AccessMethodNode node)
{
VisitAccessMethod(node,
(token, node1, exargs, arg3, alias, canSkipInjectSource) =>
new AccessMethodNode(token, node1 as ArgsListNode, exargs, canSkipInjectSource, arg3, alias));
}
public void Visit(AccessMethodNode node)
{
node.Arguments.Accept(this);
node.Accept(_visitor);
}
private void VisitAccessMethod(AccessMethodNode node)
{
var args = Nodes.Pop() as ArgsListNode;
Nodes.Push(new AccessMethodNode(node.FToken, args, null, node.Method, node.Alias));
}
public virtual void Visit(AccessMethodNode node)
{
VisitAccessMethod(node);
}
public void Visit(AccessMethodNode node)
{
}
public virtual void Visit(AccessMethodNode node)
{
Nodes.Push(new AccessMethodNode(node.FToken, (ArgsListNode)Nodes.Pop(), null, node.CanSkipInjectSource, node.Method, node.Alias));
}
private void VisitAccessMethod(AccessMethodNode node,
Func <FunctionToken, Node, ArgsListNode, MethodInfo, string, AccessMethodNode> func)
{
var args = Nodes.Pop() as ArgsListNode;
var groupArgs = new List <Type> {
typeof(string)
};
groupArgs.AddRange(args.Args.Where((f, i) => i < args.Args.Length - 1).Select(f => f.ReturnType));
var alias = !string.IsNullOrEmpty(node.Alias) ? node.Alias : _identifier;
var tableSymbol = _currentScope.ScopeSymbolTable.GetSymbol <TableSymbol>(alias);
var schemaTablePair = tableSymbol.GetTableByAlias(alias);
if (!schemaTablePair.Schema.TryResolveAggreationMethod(node.Name, groupArgs.ToArray(), out var method))
{
method = schemaTablePair.Schema.ResolveMethod(node.Name, args.Args.Select(f => f.ReturnType).ToArray());
}
var isAggregateMethod = method.GetCustomAttribute <AggregationMethodAttribute>() != null;
AccessMethodNode accessMethod;
if (isAggregateMethod)
{
accessMethod = func(node.FToken, args, node.ExtraAggregateArguments, method, alias);
var identifier = accessMethod.ToString();
var newArgs = new List <Node> {
new WordNode(identifier)
};
newArgs.AddRange(args.Args.Where((f, i) => i < args.Args.Length - 1));
var newSetArgs = new List <Node> {
new WordNode(identifier)
};
newSetArgs.AddRange(args.Args);
var setMethodName = $"Set{method.Name}";
if (!schemaTablePair.Schema.TryResolveAggreationMethod(
setMethodName,
newSetArgs.Select(f => f.ReturnType).ToArray(),
out var setMethod))
{
throw new NotSupportedException();
}
var setMethodNode = func(new FunctionToken(setMethodName, TextSpan.Empty),
new ArgsListNode(newSetArgs.ToArray()), null, setMethod,
alias);
_refreshMethods.Add(setMethodNode);
accessMethod = func(node.FToken, new ArgsListNode(newArgs.ToArray()), null, method, alias);
}
else
{
accessMethod = func(node.FToken, args, new ArgsListNode(new Node[0]), method, alias);
}
AddAssembly(method.DeclaringType.Assembly);
AddAssembly(method.ReturnType.Assembly);
node.ChangeMethod(method);
Nodes.Push(accessMethod);
}
