/// <summary>
/// Translates a given transformation schema to target's language code whose target name is given.
/// </summary>
/// <param name="schema">The transformation schema.</param>
/// <param name="targetName">The name of a target.</param>
/// <param name="schemaProcessed">Specifies if the schema has been processed by middle-end operations (ex. type inference).</param>
/// <returns></returns>
public string Translate(ITransformationSchema schema, string targetName, bool schemaProcessed = false)
{
ITargetRenderer targetRenderer = this._provider.GetTargetRenderer(targetName);
if (!schemaProcessed)
{
this._provider.GetMiddleEnd().Process(schema);
}
if (targetRenderer == null)
{
throw new NullReferenceException($"Target renderer named \"{targetName}\" has been not found.");
}
return(this._provider.GetTargetRenderer(targetName).Render(schema));
}
public TranslationResponse Tanslate(TranslationParameters parameters)
{
this._dataModelAggregator.EnvironmentMapper.Mapping = parameters.DataMappers;
this._dataModelAggregator.DefaultNamespace = parameters.DefaultNamespace;
this._dataModelAggregator.DataModelsCollection.Clear();
foreach (var dataSource in parameters.DataSources)
{
switch (dataSource.Type.ToLower())
{
case "json":
this._dataModelAggregator.AddJsonModel(dataSource.Localization);
break;
case "sdmx":
this._dataModelAggregator.AddSdmxModel(dataSource.Localization, dataSource.Namespace);
break;
case "tsql":
this._dataModelAggregator.AddSqlServerModel(dataSource.Localization);
break;
default:
return(new TranslationResponse(new ArgumentException("Unexpected model type.")));
}
}
ITransformationSchema schema = this._treeGenerator.BuildTransformationSchema(parameters.Experession);
this._schemaModifiersApplier.Process(schema);
bool areErrors = this._errorCollectorProvider.ErrorCollectors.Sum(counter => counter.Errors.Count) > 0;
if (areErrors)
{
return(new TranslationResponse(this._errorCollectorProvider.ErrorCollectors.SelectMany(ec => ec.Errors).ToList()));
}
ITargetRenderer target = this._targetRenderers.FirstOrDefault(tr => tr.Name == parameters.Target);
if (target == null)
{
return(new TranslationResponse(new ArgumentException("Unexpected target type.")));
}
return(new TranslationResponse(target.Render(schema)));
}
public string Translate(TranslateOptions parameters)
{
dataModelAggregator.DefaultNamespace = parameters.DefaultNamespace;
dataModelAggregator.DataModelsCollection.Clear();
dataModelAggregator.AddJsonModel(parameters.Model);
if (parameters.NamespaceMapping != null && parameters.NamespaceMapping != string.Empty)
{
// example mapping: "Json;Regular;Namespace=[DbSchema].[DbTable]."
foreach (string map in parameters.NamespaceMapping.Split(';'))
{
var sp = map.Split('=');
switch (sp.Length)
{
case 1:
this.mapper.Mapping.Add(sp[0], string.Empty);
break;
case 2:
this.mapper.Mapping.Add(sp[0], sp[1]);
break;
default:
throw new ArgumentException("Invalid format of namespace mapping argument");
}
}
}
else
{
this.mapper.Mapping.Add(parameters.DefaultNamespace, string.Empty);
}
ITransformationSchema schema = treeGenerator.BuildTransformationSchema(parameters.Input.OpenText().ReadToEnd());
schemaModifiersApplier.Process(schema);
ITargetRenderer target = targetRenderers.FirstOrDefault(tr => tr.Name.ToLower() == parameters.Target.ToLower());
if (target == null)
{
throw new ArgumentException("Unexpected target type.");
}
return(target.Render(schema));
}
protected string TranslateVtl(string source, out List <Exception> errors)
{
ITransformationSchema schema = this.frontEnd.BuildTransformationSchema(source);
this.middleEnd.Process(schema);
ITargetRenderer tsqlRenderer = this.provider.GetTargetRenderer("TSQL");
string sql = tsqlRenderer.Render(schema);
errors = new List <Exception>();
foreach (ErrorCollector errCollector in this.errCollectorProvider.ErrorCollectors)
{
errors.AddRange(errCollector.Errors);
}
return(sql);
}
public void RemoveTarget(ITargetRenderer target) => this.Targets.RemoveTarget(target);
public static void Main(string[] args)
{
string source = Example.Source;
string connectionString = @"Server=...;Trusted_Connection=True;";
IServiceCollection services = new ServiceCollection();
services.AddVtlProcessing((configure) =>
{
configure.DataModels.DefaultNamespace = "Json";
configure.DataModels.AddSqlServerModel(connectionString);
configure.DataModels.AddJsonModel($"{Directory.GetCurrentDirectory()}\\DataModel.json"); // namespace name is in a json file
configure.DataModels.AddDictionaryModel((config) =>
{
config
.AddDataSet(
"R1",
(ComponentType.Identifier, BasicDataType.Integer, "Id1"),
(ComponentType.Identifier, BasicDataType.Integer, "Id2"),
(ComponentType.Measure, BasicDataType.Integer, "Me1"),
(ComponentType.Measure, BasicDataType.Integer, "Me2"),
(ComponentType.NonViralAttribute, BasicDataType.String, "At1"),
(ComponentType.ViralAttribute, BasicDataType.Integer, "At2")
)
.AddDataSet(
"R2",
(ComponentType.Identifier, BasicDataType.Integer, "Id1"),
(ComponentType.Measure, BasicDataType.String, "Me1"),
(ComponentType.Measure, BasicDataType.Integer, "Me2")
)
.AddDataSet(
"R_num",
(ComponentType.Identifier, BasicDataType.Integer, "Id1"),
(ComponentType.Measure, BasicDataType.Number, "Me2")
);
}
, "def_ns");
configure.EnvironmentMapper.Mapping = new Dictionary <string, string>()
{
{ "Json", string.Empty },
{ "Regular", string.Empty },
{ "Pivot", "[VtlProcessingTests].[Pivoting]." },
};
});
services.AddPlantUmlTarget((configure) =>
{
configure.AddDataStructureObject();
configure.UseArrowFirstToLast();
configure.ShowNumberLine();
configure.UseRuleExpressionsModel();
});
services.AddTsqlTarget((configure) =>
{
configure.AddComments();
});
services.AddLogging((configure) =>
{
configure.AddConsole();
configure.AddDebug();
configure.AddProvider(new ErrorCollectorProvider());
});
ServiceProvider provider = services.BuildServiceProvider();
ErrorCollectorProvider errColector = provider.GetService <ILoggerProvider>() as ErrorCollectorProvider;
ITransformationSchema schema = provider.GetFrontEnd().BuildTransformationSchema(source); // front-end
provider.GetMiddleEnd().Process(schema); // middle-end
bool areErrors = errColector.ErrorCollectors.Sum(counter => counter.Errors.Count) > 0;
// back-end:
ITargetRenderer plantUmlRenderer = provider.GetTargetRenderer("PlantUML");
string plantUmlResult = plantUmlRenderer.Render(schema);
PlantUmlUrlConverter converter = new PlantUmlUrlConverter(plantUmlResult);
if (!areErrors)
{
ITargetRenderer tsqlRenderer = provider.GetTargetRenderer("TSQL");
Process.Start("cmd.exe", $"/C start {converter.SVGUrl}");
FilesManager.ResultToFile(plantUmlResult, "result.plantuml");
FilesManager.ResultToFile(tsqlRenderer.Render(schema), "result.sql");
}
else
{
Debug.WriteLine($"\n\n{converter.SVGUrl}\n\n");
}
}
/// <summary>
/// Removes a target from the collection but doesn't remove its dependent sevices.
/// </summary>
/// <param name="target">The target to remove.</param>
internal void RemoveTarget(ITargetRenderer target)
{
this._targets.Remove(this._targets.FirstOrDefault(s => s.ImplementationInstance == target));
this._services.Remove(this._services.FirstOrDefault(s => s.ImplementationInstance == target));
}
