internal static CommandBase FromCode(SyntaxElement rootElement)
{
var tableNameDeclaration = rootElement.GetUniqueDescendant <NameDeclaration>(
"Table Name",
n => n.NameInParent == "TableName");
var mappingNameExpression = rootElement.GetUniqueDescendant <LiteralExpression>(
"Mapping Name",
n => n.NameInParent == "MappingName");
var mappingKindToken = rootElement.GetUniqueDescendant <SyntaxToken>(
"Mapping Kind",
n => n.NameInParent == "MappingKind");
var mappingFormatExpression = rootElement.GetUniqueDescendant <LiteralExpression>(
"Mapping Format",
n => n.NameInParent == "MappingFormat");
var mappingFormatFirstPart = QuotedText.FromLiteral(mappingFormatExpression);
var mappingFormatExtraParts = rootElement
.GetDescendants <CompoundStringLiteralExpression>()
.SelectMany(c => c.Tokens)
.Select(t => QuotedText.FromToken(t));
var mappingFormatParts = mappingFormatExtraParts
.Prepend(mappingFormatFirstPart)
.Select(q => q.Text);
var mappingFormat = string.Concat(mappingFormatParts);
var command = new CreateMappingCommand(
EntityName.FromCode(tableNameDeclaration),
mappingKindToken.Text,
QuotedText.FromLiteral(mappingNameExpression),
QuotedText.FromText(mappingFormat) !);
return(command);
}
public SyntaxElement ParseSyntax()
{
ParseToken("syntax");
string name = ParseName();
SyntaxElement syntax = new SyntaxElement(name);
ParseToken("=");
for (Token tk = this.PeekToken(); tk != null && tk.Value != ";"; tk = this.PeekToken())
{
switch (tk.TokenType)
{
case TokenType.Name:
syntax.AddPrimaryExpression(this.ParseIdentifier());
break;
case TokenType.String:
syntax.AddPrimaryExpression(this.ParseTextLiteral());
break;
default:
throw new UnexpectedTokenException(tk);
}
}
ParseToken(";");
return(syntax);
}
/// <summary>
/// Returns true if the symbol of element <paramref name="element"/>
/// is equal to <paramref name="symbol"/>
/// </summary>
private static bool AreSymbolsEqual(Symbol symbol, SyntaxElement element, FindRelatedOptions options)
{
var canSee = (options & FindRelatedOptions.SeeThroughVariables) != 0;
return((element is NameReference n && (n.ReferencedSymbol == symbol || (canSee && n.ReferencedSymbol == Symbol.GetExpressionResultType(symbol)))) ||
(element is NameDeclaration d && (d.ReferencedSymbol == symbol || (canSee && Symbol.GetExpressionResultType(d.ReferencedSymbol) == symbol))));
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var identifiers = rootElement
.GetDescendants<SyntaxNode>(e => e.NameInParent == "Name"
&& e.Kind != SyntaxKind.BracketedName)
.Select(t => EntityName.FromCode(t));
var literals = rootElement
.GetDescendants<LiteralExpression>(e => e.NameInParent == "DocString")
.Select(l => new QuotedText(l.LiteralValue.ToString()!));
if (identifiers.Count() < 1)
{
throw new DeltaException("There should be at least one identifier in the command");
}
if (identifiers.Count() != literals.Count() + 1)
{
throw new DeltaException("Mismatch number of identifiers vs literals");
}
var tableName = identifiers.First();
var columns = identifiers
.Skip(1)
.Zip(literals, (id, lit) => new ColumnDocString(id, lit));
return new AlterMergeTableColumnDocStringsCommand(tableName, columns);
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var cleanTableName = rootElement
.GetDescendants <TokenName>(e => e.NameInParent == "Name")
.FirstOrDefault();
var tableName = rootElement.GetDescendants <NameReference>().Last();
if ((cleanTableName == null || cleanTableName.Name.Text == string.Empty) &&
tableName == null)
{
throw new DeltaException("Can't find table name");
}
var policiesText = QuotedText.FromLiteral(
rootElement.GetUniqueDescendant <LiteralExpression>(
"UpdatePolicy",
e => e.NameInParent == "UpdatePolicy"));
var policies = Deserialize <UpdatePolicy[]>(policiesText.Text);
if (policies == null)
{
throw new DeltaException(
$"Can't extract policy objects from {policiesText.ToScript()}");
}
return(new AlterUpdatePolicyCommand(
EntityName.FromCode(tableName.Name),
policies));
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var entityKinds = rootElement
.GetDescendants <SyntaxElement>(s => s.Kind == SyntaxKind.TableKeyword ||
s.Kind == SyntaxKind.DatabaseKeyword)
.Select(s => s.Kind);
if (!entityKinds.Any())
{
throw new DeltaException("Alter caching policy requires to act on a table or database (cluster isn't supported)");
}
var entityKind = entityKinds.First();
var entityType = entityKind == SyntaxKind.TableKeyword
? EntityType.Table
: EntityType.Database;
var entityName = rootElement
.GetDescendants <NameReference>(n => n.NameInParent == "TableName" ||
n.NameInParent == "DatabaseName" ||
n.NameInParent == "Selector")
.Last();
var(hotData, hotIndex) = ExtractHotDurations(rootElement);
return(new AlterCachingPolicyCommand(
entityType,
EntityName.FromCode(entityName.Name),
hotData,
hotIndex));
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var entityKinds = rootElement
.GetDescendants <SyntaxElement>(s => s.Kind == SyntaxKind.TableKeyword ||
s.Kind == SyntaxKind.DatabaseKeyword)
.Select(s => s.Kind);
if (!entityKinds.Any())
{
throw new DeltaException("Alter retention policy requires to act on a table or database (cluster isn't supported)");
}
var entityKind = entityKinds.First();
var entityType = entityKind == SyntaxKind.TableKeyword
? EntityType.Table
: EntityType.Database;
var entityName = rootElement.GetDescendants <NameReference>().Last();
var policyText = QuotedText.FromLiteral(
rootElement.GetUniqueDescendant <LiteralExpression>(
"RetentionPolicy",
e => e.NameInParent == "RetentionPolicy"));
var policy = Deserialize <JsonDocument>(policyText.Text);
if (policy == null)
{
throw new DeltaException(
$"Can't extract policy objects from {policyText.ToScript()}");
}
return(new AlterRetentionPolicyCommand(
entityType,
EntityName.FromCode(entityName.Name),
policy));
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var functionName = EntityName.FromCode(
rootElement.GetUniqueDescendant <SyntaxElement>(
"Function Name",
e => e.NameInParent == "FunctionName"));
var functionDeclaration = rootElement
.GetAtLeastOneDescendant <FunctionDeclaration>("Function declaration")
.First();
var body = TrimFunctionSchemaBody(functionDeclaration.Body.ToString());
var parameters = functionDeclaration
.Parameters
.Parameters
.Select(p => p.Element)
.Select(fp => GetParameter(fp));
var folder = GetProperty(rootElement, SyntaxKind.FolderKeyword);
var docString = GetProperty(rootElement, SyntaxKind.DocStringKeyword);
return(new CreateFunctionCommand(
functionName,
parameters,
body,
folder,
docString));
}
private static (TimeSpan hotData, TimeSpan hotIndex) ExtractHotDurations(
SyntaxElement rootElement)
{
var durations = GetHotDurations(rootElement);
if (durations.Count == 1 && durations.ContainsKey(SyntaxKind.HotKeyword))
{
var duration = durations.First().Value;
return(duration, duration);
}
else if (durations.Count == 2 &&
durations.ContainsKey(SyntaxKind.HotDataKeyword) &&
durations.ContainsKey(SyntaxKind.HotIndexKeyword))
{
var dataDuration = durations[SyntaxKind.HotDataKeyword];
var indexDuration = durations[SyntaxKind.HotIndexKeyword];
return(dataDuration, indexDuration);
}
else
{
throw new DeltaException("Caching policy expect either a 'hot' parameter or a 'hotdata' and 'hotindex'");
}
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var tableName = rootElement.GetUniqueDescendant <NameDeclaration>(
"TableName",
n => n.NameInParent == "TableName");
var folder = GetProperty(rootElement, SyntaxKind.FolderKeyword);
var docString = GetProperty(rootElement, SyntaxKind.DocStringKeyword);
var columns = rootElement
.GetDescendants <NameDeclaration>(n => n.NameInParent == "ColumnName")
.Select(n => n.Parent)
.Select(n => new
{
Name = n.GetUniqueDescendant <NameDeclaration>("Table column name"),
Type = n.GetUniqueDescendant <PrimitiveTypeExpression>("Table column type")
})
.Select(c => new TableColumn(
EntityName.FromCode(c.Name),
c.Type.Type.Text));
return(new CreateTableCommand(
EntityName.FromCode(tableName),
columns,
folder,
docString));
}
public ScriptVariable Invoke(IScriptFunction function, IList <ScriptVariable> args)
{
if (function == null)
{
throw new ArgumentNullException("function", "'function' cannot be null");
}
if (args == null)
{
args = new List <ScriptVariable>();
}
bool topLevelInvoke = _executedFunctionStack.Count == 0;
_executedFunctionStack.Push(function);
try {
ScriptVariable result = function.Call(args, this);
if (topLevelInvoke)
{
this.PushHistory(new FunctionCallHistory(function, args, result));
}
return(result);
} catch {
_lastSyntaxOnError = _executedSyntaxElementStack.Count > 0 ? _executedSyntaxElementStack.Peek() : null;
_lastSubroutineOnError = _executedFunctionStack.Peek().Name;
throw;
} finally {
_executedFunctionStack.Pop();
}
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var nameReference = rootElement.GetUniqueDescendant <NameReference>(
"FunctionName",
n => n.NameInParent == "FunctionName");
return(new DropFunctionCommand(new EntityName(nameReference.Name.SimpleName)));
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var nameReferences = rootElement.GetDescendants <NameReference>();
var names = nameReferences
.Select(n => new EntityName(n.Name.SimpleName))
.ToImmutableArray();
return(new DropTablesCommand(names));
}
private void FlushAccumulatedLitteralContent()
{
if (_literalGroupingAccumulator.Length != 0)
{
var groupedLitteralElements = new SyntaxElement(_literalGroupingAccumulator.ToString(), SyntaxElementKind.Litteral);
_elements.Add(groupedLitteralElements);
_literalGroupingAccumulator.Clear();
}
}
public QmlSyntaxTag(
ITextSnapshot snapshot,
SyntaxElement element,
string classificationType,
SourceLocation location)
: this(snapshot, location)
{
SyntaxElement = element;
ClassificationType = QmlClassificationType.Get(classificationType);
}
private static QuotedText?GetProperty(SyntaxElement rootElement, SyntaxKind kind)
{
var literal = rootElement
.GetDescendants <SyntaxElement>(e => e.Kind == kind)
.Select(e => e.Parent.GetDescendants <LiteralExpression>().FirstOrDefault())
.FirstOrDefault();
return(literal == null
? null
: QuotedText.FromLiteral(literal));
}
public static IReadOnlyList <TElement> GetImmediateDescendants <TElement>(
this SyntaxElement parent,
Func <TElement, bool>?predicate = null)
where TElement : SyntaxElement
{
var descendants = parent.GetDescendants <TElement>(
e => e.Parent == parent &&
(predicate == null || predicate(e)));
return(descendants);
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var tableNameReference = rootElement.GetUniqueDescendant <NameReference>(
"Table name",
n => n.NameInParent == "TableName");
var columnNameReferences = rootElement.GetDescendants <NameReference>(
n => n.NameInParent != "TableName");
var tableName = new EntityName(tableNameReference.Name.SimpleName);
var columnNames = columnNameReferences
.Select(n => new EntityName(n.Name.SimpleName))
.ToImmutableArray();
return(new DropTableColumnsCommand(tableName, columnNames));
}
public void ShouldParseSyntaxWithTwoTextLiterals()
{
Parser parser = new Parser("syntax Main = \"Hello\" \"World\";");
SyntaxElement syntax = parser.ParseSyntax();
Assert.IsNotNull(syntax);
Assert.AreEqual("Main", syntax.Name);
Assert.AreEqual(2, syntax.Expressions.Count);
foreach (PrimaryExpression expression in syntax.Expressions)
{
Assert.IsInstanceOfType(expression, typeof(TextLiteral));
}
}
public void ShouldParseSyntaxWithTwoIdentifiers()
{
Parser parser = new Parser("syntax Main = Hello World;");
SyntaxElement syntax = parser.ParseSyntax();
Assert.IsNotNull(syntax);
Assert.AreEqual("Main", syntax.Name);
Assert.AreEqual(2, syntax.Expressions.Count);
foreach (PrimaryExpression expression in syntax.Expressions)
{
Assert.IsInstanceOfType(expression, typeof(Identifier));
}
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var nameReferences = rootElement.GetDescendants <NameReference>();
if (nameReferences.Count != 2)
{
throw new DeltaException($"Expected 2 names but got {nameReferences.Count}");
}
var tableName = new EntityName(nameReferences[0].Name.SimpleName);
var columnName = new EntityName(nameReferences[1].Name.SimpleName);
var typeExpression = rootElement.GetUniqueDescendant <PrimitiveTypeExpression>("Primitive type");
var type = typeExpression.Type.ValueText;
return(new AlterColumnTypeCommand(tableName, columnName, type));
}
public void ShouldParseSyntaxWithOneTextLiteral()
{
Parser parser = new Parser("syntax Main = \"Hello\";");
SyntaxElement syntax = parser.ParseSyntax();
Assert.IsNotNull(syntax);
Assert.AreEqual("Main", syntax.Name);
Assert.AreEqual(1, syntax.Expressions.Count);
Assert.IsInstanceOfType(syntax.Expressions.First(), typeof(TextLiteral));
TextLiteral literal = (TextLiteral)syntax.Expressions.First();
Assert.AreEqual("Hello", literal.Value);
}
public void ShouldParseSyntaxWithOneIdentifier()
{
Parser parser = new Parser("syntax Main = Hello;");
SyntaxElement syntax = parser.ParseSyntax();
Assert.IsNotNull(syntax);
Assert.AreEqual("Main", syntax.Name);
Assert.AreEqual(1, syntax.Expressions.Count);
Assert.IsInstanceOfType(syntax.Expressions.First(), typeof(Identifier));
Identifier identifier = (Identifier)syntax.Expressions.First();
Assert.AreEqual("Hello", identifier.Name);
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var tableName = rootElement.GetDescendants <NameReference>().Last();
var policyText = QuotedText.FromLiteral(
rootElement.GetUniqueDescendant <LiteralExpression>(
"AutoDeletePolicy",
e => e.NameInParent == "AutoDeletePolicy"));
var policy = Deserialize <JsonDocument>(policyText.Text);
if (policy == null)
{
throw new DeltaException(
$"Can't extract policy objects from {policyText.ToScript()}");
}
return(new AlterAutoDeletePolicyCommand(EntityName.FromCode(tableName.Name), policy));
}
public static IEnumerable <TElement> GetAtLeastOneDescendant <TElement>(
this SyntaxElement parent,
string descendantNameForExceptionMessage,
Func <TElement, bool>?predicate = null)
where TElement : SyntaxElement
{
var descendants = parent.GetDescendants <TElement>(predicate);
if (!descendants.Any())
{
throw new DeltaException(
$"There should be at least one {descendantNameForExceptionMessage} but there are none",
parent.Root.ToString(IncludeTrivia.All));
}
return(descendants);
}
public static TElement GetUniqueDescendant <TElement>(
this SyntaxElement parent,
string descendantNameForExceptionMessage,
Func <TElement, bool>?predicate = null)
where TElement : SyntaxElement
{
var descendants = parent.GetDescendants <TElement>(predicate);
if (descendants.Count != 1)
{
throw new DeltaException(
$"There should be one-and-only-one {descendantNameForExceptionMessage} but there are {descendants.Count}",
parent.Root.ToString(IncludeTrivia.All));
}
return(descendants.First());
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var tableNameReference = rootElement.GetUniqueDescendant <NameReference>(
"Table Name",
n => n.NameInParent == "TableName");
var mappingNameExpression = rootElement.GetUniqueDescendant <LiteralExpression>(
"Mapping Name",
n => n.NameInParent == "MappingName");
var mappingKindToken = rootElement.GetUniqueDescendant <SyntaxToken>(
"Mapping Kind",
n => n.NameInParent == "MappingKind");
var command = new DropMappingCommand(
new EntityName(tableNameReference.SimpleName),
mappingKindToken.Text,
QuotedText.FromLiteral(mappingNameExpression));
return(command);
}
/// <summary>
/// Walks the entire syntax tree and evaluates the maximum depth of all the nodes.
/// </summary>
private static int ComputeMaxDepth(SyntaxElement root)
{
var maxDepth = 0;
var depth = 0;
SyntaxElement.Walk(
root,
fnBefore: e =>
{
depth++;
if (depth > maxDepth)
{
maxDepth = depth;
}
},
fnAfter: e => depth--);
return(maxDepth);
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var entityKinds = rootElement
.GetDescendants <SyntaxElement>(s => s.Kind == SyntaxKind.TableKeyword ||
s.Kind == SyntaxKind.DatabaseKeyword)
.Select(s => s.Kind);
if (!entityKinds.Any())
{
throw new DeltaException("Delete ingestionbatching policy requires to act on a table or database (cluster isn't supported)");
}
var entityKind = entityKinds.First();
var entityType = entityKind == SyntaxKind.TableKeyword
? EntityType.Table
: EntityType.Database;
var entityName = rootElement.GetFirstDescendant <NameReference>();
return(new DeleteIngestionBatchingPolicyCommand(entityType, EntityName.FromCode(entityName.Name)));
}
public static EntityName FromCode(SyntaxElement element)
{
switch (element)
{
case NameDeclaration nameDeclaration:
return(new EntityName(nameDeclaration.Name.SimpleName));
case TokenName tokenName:
return(new EntityName(tokenName.Name.Text));
case LiteralExpression literal:
return(new EntityName((string)literal.LiteralValue));
case BracketedName bracketedName:
return(new EntityName((string)bracketedName.Name.LiteralValue));
default:
return(new EntityName(element.ToString()));
}
}
internal static CommandBase FromCode(SyntaxElement rootElement)
{
var(folder, docString) = ExtractWithProperties(rootElement);
Func <NameDeclaration, InnerTable> tableExtraction = (table) =>
{
var columns = table
.Parent
.GetDescendants <SeparatedElement>()
.Select(s => new TableColumn(
EntityName.FromCode(s.GetUniqueDescendant <NameDeclaration>("Column Name")),
s.GetUniqueDescendant <PrimitiveTypeExpression>("Column Type").Type.Text));
return(new InnerTable(EntityName.FromCode(table), columns));
};
var tables = rootElement
.GetDescendants <NameDeclaration>(n => n.NameInParent == "TableName")
.Select(t => tableExtraction(t));
return(new CreateTablesCommand(tables, folder, docString));
}
public int DecodeCABAC(SliceHeader header, SyntaxElement se)
{
// FIXME: do nothing for now
return 0;
}
public SourceFileParsingInfo(string path, SyntaxElement[] elements)
{
Path = path;
Elements = elements;
}
private bool IsPurelyLitteral(SyntaxElement element)
{
return
element.Kind == SyntaxElementKind.Litteral ||
(element as TriviaSyntaxElement)?.TriviaKind == TriviaSyntaxElementKind.Whitespace;
}
