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 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));
}
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));
}
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);
}
private static TypedParameterModel GetParameter(FunctionParameter functionParameter)
{
var declaration = functionParameter.NameAndType;
var defaultValue = functionParameter.DefaultValue;
var(name, type) = declaration
.GetImmediateDescendants <SyntaxNode>()
.ExtractChildren <NameDeclaration, TypeExpression>("Parameter pair");
if (type is PrimitiveTypeExpression)
{
var typeExpression = type as PrimitiveTypeExpression;
return(new TypedParameterModel(
EntityName.FromCode(name),
typeExpression !.Type.ValueText,
defaultValue != null ? defaultValue.ToString() : null));
}
else
{
var typeExpression = type as SchemaTypeExpression;
var cols = typeExpression !.Columns;
// Consider the case T(*)
if (cols.Count == 1 &&
cols.First().GetImmediateDescendants <NameAndTypeDeclaration>().Count == 0)
{
return(new TypedParameterModel(
EntityName.FromCode(name),
new TableParameterModel(new TableColumn[0])));
}
else
{
var columns = typeExpression !
.Columns
.Select(c => c.GetUniqueImmediateDescendant <NameAndTypeDeclaration>("Function parameter table column"))
.Select(n => GetColumnSchema(n));
var table = new TableParameterModel(columns);
return(new TypedParameterModel(
EntityName.FromCode(name),
table));
}
}
}
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));
}
