public static QsiFunctionExpressionNode CreateFunction(string identifier)
{
return(new()
{
Identifier = new QsiQualifiedIdentifier(new QsiIdentifier(identifier, false))
});
}
protected override async ValueTask <IQsiAnalysisResult> OnExecute(IAnalyzerContext context)
{
var identifierSet = new HashSet <QsiIdentifier>(IdentifierComparer);
QsiQualifiedIdentifier tableIdentifier = null;
QsiTableNode node = (context.Tree as QsiDerivedTableNode);
bool isCountFunction = false;
while (node is QsiDerivedTableNode tableNode)
{
IEnumerable <QsiQualifiedIdentifier> columns = tableNode
.Columns.Value
.FindAscendants <QsiDeclaredColumnNode>()
.Select(c => c.Name);
var hasCountFunction = tableNode
.Columns.Value
.FindAscendants <QsiDerivedColumnNode>()
.Any(c => c.Expression.Value is QsiInvokeExpressionNode invokeExpressionNode &&
invokeExpressionNode.Member.Value.Identifier[^ 1].Value.EqualsIgnoreCase("COUNT"));
if (hasCountFunction)
{
isCountFunction = true;
}
foreach (var column in columns)
{
identifierSet.Add(column[^ 1]);
public ImmutableAllColumnNode(IQsiTreeNode parent, QsiQualifiedIdentifier path, IUserDataHolder userData)
{
Parent = parent;
Path = path;
UserData = userData;
IncludeInvisibleColumns = false;
}
private QsiQualifiedIdentifier PatchQualifiedIdentifier(QsiQualifiedIdentifier qualifiedIdentifier)
{
QsiIdentifier[] identifiers = qualifiedIdentifier
.Select(PatchQualifiedIdentifier)
.ToArray();
return(new QsiQualifiedIdentifier(identifiers));
}
public ImmutableTableReferenceNode(
IQsiTreeNode parent,
QsiQualifiedIdentifier identifier,
IUserDataHolder userData)
{
Parent = parent;
Identifier = identifier;
UserData = userData;
}
public ImmutableExecutePrepareActionNode(
IQsiTreeNode parent,
QsiQualifiedIdentifier identifier,
IQsiMultipleExpressionNode variables,
IUserDataHolder userData)
{
Parent = parent;
Identifier = identifier;
Variables = variables;
UserData = userData;
}
public ImmutableSetColumnExpressionNode(
IQsiTreeNode parent,
QsiQualifiedIdentifier target,
IQsiExpressionNode value,
IUserDataHolder userData)
{
Parent = parent;
Target = target;
Value = value;
UserData = userData;
}
public ImmutablePrepareActionNode(
IQsiTreeNode parent,
QsiQualifiedIdentifier identifier,
IQsiExpressionNode query,
IUserDataHolder userData)
{
Parent = parent;
Identifier = identifier;
Query = query;
UserData = userData;
}
public ImmutableDataConflictActionNode(
IQsiTreeNode parent,
QsiQualifiedIdentifier target,
IQsiSetColumnExpressionNode[] setValues,
IQsiExpressionNode condition,
IUserDataHolder userData)
{
Parent = parent;
Target = target;
SetValues = setValues;
Condition = condition;
UserData = userData;
}
public ImmutableSetVariableExpressionNode(
IQsiTreeNode parent,
QsiQualifiedIdentifier target,
QsiAssignmentKind assignmentKind,
IQsiExpressionNode value,
IUserDataHolder userData)
{
Parent = parent;
Target = target;
AssignmentKind = assignmentKind;
Value = value;
UserData = userData;
}
public static QsiColumnNode CreateColumnNode(QsiQualifiedIdentifier identifier, QsiSequentialColumnType?sequence = null)
{
QsiColumnNode node;
if (sequence.HasValue)
{
node = new QsiSequentialColumnNode
{
ColumnType = sequence.Value,
Alias =
{
Value = new QsiAliasNode
{
Name = identifier[^ 1]
protected bool Match(IAnalyzerContext context, QsiTableStructure table, QsiQualifiedIdentifier identifier)
{
if (!table.HasIdentifier)
{
return(false);
}
// * case - Explicit access
// ┌──────────────────────────────────────────────────────────┐
// │ SELECT sakila.actor.column FROM sakila.actor │
// │ ▔▔▔▔▔▔^▔▔▔▔▔ == ▔▔▔▔▔▔^▔▔▔▔▔ │
// │ └-> identifier(2) └-> table.Identifier(2) │
// └──────────────────────────────────────────────────────────┘
if (Match(table.Identifier, identifier))
{
return(true);
}
// * case - 2 Level implicit access
// ┌──────────────────────────────────────────────────────────┐
// │ SELECT actor.column FROM sakila.actor │
// │ ▔▔▔▔▔ < ▔▔▔▔▔^▔▔▔▔▔ │
// │ └-> identifier(1) └-> table.Identifier(2) │
// └──────────────────────────────────────────────────────────┘
// * case - 3 Level implicit access
// ┌──────────────────────────────────────────────────────────┐
// │ SELECT sakila.actor.column FROM db.sakila.actor │
// │ ▔▔▔▔▔▔^▔▔▔▔▔ < ▔▔^▔▔▔▔▔▔^▔▔▔▔▔ │
// │ └-> identifier(2) └-> table.Identifier(3) │
// └──────────────────────────────────────────────────────────┘
if (context.Options.UseExplicitRelationAccess)
{
return(false);
}
if (!QsiUtility.IsReferenceType(table.Type))
{
return(false);
}
if (table.Identifier.Level <= identifier.Level)
{
return(false);
}
QsiIdentifier[] partialIdentifiers = table.Identifier[^ identifier.Level..];
protected override QsiQualifiedIdentifier ResolveQualifiedIdentifier(QsiQualifiedIdentifier identifier)
{
if (identifier.Level == 1)
{
var sakila = new QsiIdentifier("sakila", false);
identifier = new QsiQualifiedIdentifier(sakila, identifier[0]);
}
if (identifier.Level != 2)
{
throw new InvalidOperationException();
}
return(identifier);
}
QsiTableStructure IQsiRepositoryProvider.LookupTable(QsiQualifiedIdentifier identifier)
{
if (CacheRepository == null)
{
return(LookupTable(identifier));
}
if (!CacheRepository.TryGetTable(identifier, out var table))
{
table = LookupTable(identifier);
CacheRepository.SetTable(identifier, table);
}
return(table);
}
QsiScript IQsiRepositoryProvider.LookupDefinition(QsiQualifiedIdentifier identifier, QsiTableType type)
{
if (CacheRepository == null)
{
return(LookupDefinition(identifier, type));
}
if (!CacheRepository.TryGetDefinition(identifier, out var definition))
{
definition = LookupDefinition(identifier, type);
CacheRepository.SetDefinition(identifier, definition);
}
return(definition);
}
protected bool Match(QsiQualifiedIdentifier a, QsiQualifiedIdentifier b)
{
if (a.Level != b.Level)
{
return(false);
}
for (int i = 0; i < a.Level; i++)
{
if (!Match(a[i], b[i]))
{
return(false);
}
}
return(true);
}
protected override QsiQualifiedIdentifier ResolveQualifiedIdentifier(QsiQualifiedIdentifier identifier)
{
identifier = identifier.Level switch
{
1 => new QsiQualifiedIdentifier(
new QsiIdentifier("master", false),
new QsiIdentifier("chequer", false),
identifier[0]
),
2 => new QsiQualifiedIdentifier(
new QsiIdentifier("master", false),
identifier[0],
identifier[1]
),
_ => identifier
};
if (identifier.Level != 3)
{
throw new InvalidOperationException();
}
return(identifier);
}
protected abstract QsiVariable LookupVariable(QsiQualifiedIdentifier identifier);
public ImmutableColumnReferenceNode(IQsiTreeNode parent, QsiQualifiedIdentifier name, IUserDataHolder userData)
{
Parent = parent;
Name = name;
UserData = userData;
}
public ImmutableFunctionExpressionNode(IQsiTreeNode parent, QsiQualifiedIdentifier identifier, IUserDataHolder userData)
{
Parent = parent;
Identifier = identifier;
UserData = userData;
}
public void PushIdentifierScope(QsiQualifiedIdentifier identifier)
{
_identifierScope ??= new Stack <QsiQualifiedIdentifier>();
_identifierScope.Push(identifier);
}
QsiQualifiedIdentifier IQsiRepositoryProvider.ResolveQualifiedIdentifier(QsiQualifiedIdentifier identifier)
{
return(ResolveQualifiedIdentifier(identifier));
}
QsiVariable IQsiRepositoryProvider.LookupVariable(QsiQualifiedIdentifier identifier)
{
return(LookupVariable(identifier));
}
public void SetDefinition(QsiQualifiedIdentifier identifier, QsiScript script)
{
_lookupDefinitionCache[identifier] = script;
}
protected override QsiQualifiedIdentifier ResolveQualifiedIdentifier(QsiQualifiedIdentifier identifier)
{
return(identifier);
}
protected override QsiTableStructure LookupTable(QsiQualifiedIdentifier identifier)
{
var tableName = IdentifierUtility.Unescape(identifier[^ 1].Value);
protected abstract QsiTableStructure LookupTable(QsiQualifiedIdentifier identifier);
protected abstract QsiQualifiedIdentifier ResolveQualifiedIdentifier(QsiQualifiedIdentifier identifier);
protected override QsiTableStructure LookupTable(QsiQualifiedIdentifier identifier)
{
var tableName = GetName(identifier[^ 1]);
protected abstract QsiScript LookupDefinition(QsiQualifiedIdentifier identifier, QsiTableType type);
