protected static string GetEntityOutputName(TflEntity entity, string processName)
{
var tflEntity = new Entity {
Alias = entity.Alias,
Name = entity.Name,
PrependProcessNameToOutputName = entity.PrependProcessNameToOutputName
};
return(Common.EntityOutputName(tflEntity, processName));
}
private void GuardAgainstMissingFields(TflEntity element, Entity entity, short entityIndex)
{
if (_process.Mode != "metadata" && element.Fields.Count == 0)
{
try {
_process.Logger.EntityInfo(entity.Name, "Detecting fields.");
var connection = entity.Input.First().Connection;
var fields = connection.GetEntitySchema(_process, entity, entityIndex == 0);
if (!fields.Any())
{
return;
}
foreach (var field in fields)
{
if (String.IsNullOrEmpty(field.Label) || field.Label.Equals(field.Alias))
{
field.Label = MetaDataWriter.AddSpacesToSentence(field.Alias, true).Replace("_", " ");
}
var name = field.Name;
var f = element.GetDefaultOf <TflField>(x => x.Name = name);
f.Type = field.Type;
f.Length = field.Length;
f.PrimaryKey = field.FieldType.Equals(FieldType.PrimaryKey) || field.FieldType.Equals(FieldType.MasterKey);
f.Output = true;
f.Default = string.Empty;
f.Input = true;
f.Precision = field.Precision;
f.Scale = field.Scale;
f.Label = field.Label;
element.Fields.Add(f);
}
_process.Logger.EntityInfo(entity.Name, "Detected {0} fields.", fields.Count);
} catch (Exception ex) {
throw new TransformalizeException(_process.Logger, "No fields defined. Unable to detect them for {0}. {1}", entity.Name, ex.Message);
} finally {
if (element.Fields.Count == 0)
{
throw new TransformalizeException(_process.Logger, entity.Name, "No fields defined. Unable to detect them for {0}.", entity.Name);
}
}
}
}
private PipelineThreading DetermineThreading(TflEntity element)
{
var threading = PipelineThreading.Default;
if (_process.PipelineThreading != PipelineThreading.Default)
{
threading = _process.PipelineThreading;
}
if (!element.PipelineThreading.Equals("Default"))
{
PipelineThreading entityThreading;
if (Enum.TryParse(element.PipelineThreading, true, out entityThreading))
{
threading = entityThreading;
}
}
return(threading);
}
private void LoadVersion(TflEntity element, Entity entity)
{
if (String.IsNullOrEmpty(element.Version))
{
return;
}
if (entity.Fields.HaveField(entity.Alias, element.Version))
{
entity.Version = entity.Fields.Find(entity.Alias, element.Version).First();
}
else
{
if (entity.CalculatedFields.HaveField(entity.Alias, element.Version))
{
entity.Version = entity.CalculatedFields.Find(entity.Alias, element.Version).First();
}
else
{
throw new TransformalizeException(_process.Logger, "version field reference '{0}' is undefined in {1}.", element.Version, element.Name);
}
}
entity.Version.Output = true;
}
public EntityBuilder(ProcessBuilder processBuilder, TflEntity entity) {
_processBuilder = processBuilder;
_entity = entity;
}
public EntityBuilder Entity(string name) {
var entity = new TflEntity { Name = name }.WithDefaults();
_process.Entities.Add(entity);
return new EntityBuilder(this, entity);
}
public Entity Read(TflEntity element, short entityIndex)
{
var entity = new Entity()
{
ProcessName = _process.Name,
Schema = element.Schema,
PipelineThreading = DetermineThreading(element),
Name = element.Name,
Prefix = element.Prefix,
Group = element.Group,
Delete = element.Delete,
PrependProcessNameToOutputName = element.PrependProcessNameToOutputName,
Sample = element.Sample,
DetectChanges = element.DetectChanges,
TrimAll = element.TrimAll,
NoLock = element.NoLock,
Unicode = element.Unicode,
VariableLength = element.VariableLength,
SqlOverride = element.Query,
SqlScriptOverride = element.Script,
SqlKeysOverride = element.QueryKeys,
Alias = string.IsNullOrEmpty(element.Alias) ? element.Name : element.Alias,
InputOperation = element.InputOperation,
Index = entityIndex
};
// wire up connections
if (_process.Connections.Contains(element.Connection))
{
entity.Input.Add(_process.Connections.GetConnectionByName(element.Connection).NamedConnection());
}
else
{
_process.Logger.EntityWarn(element.Name, "Could not find connection '{0}'.", element.Connection);
}
//needs an input connection
GuardAgainstMissingFields(element, entity, entityIndex);
//fields
short autoIndex = 0;
foreach (TflField f in element.Fields)
{
var fieldType = GetFieldType(f, entityIndex == 0);
var field = new FieldReader(_process, entity).Read(f, fieldType);
if (field.Index.Equals(short.MaxValue))
{
field.Index = autoIndex;
}
entity.Fields.Add(field);
if (f.PrimaryKey)
{
entity.PrimaryKey.Add(field);
}
autoIndex++;
}
foreach (var cf in element.CalculatedFields)
{
var fieldReader = new FieldReader(_process, entity, usePrefix: false);
var fieldType = GetFieldType(cf, entityIndex == 0);
var field = fieldReader.Read(cf, fieldType);
if (field.Index.Equals(short.MaxValue))
{
field.Index = autoIndex;
}
field.IsCalculated = true;
field.Input = false;
entity.CalculatedFields.Add(field);
if (cf.PrimaryKey)
{
entity.PrimaryKey.Add(field);
}
autoIndex++;
}
//depend on fields
LoadVersion(element, entity);
LoadFilter(element.Filter, entity, _process.Logger);
entity.Input.AddRange(PrepareIo(element.Input, entity.Fields));
entity.Output = PrepareIo(element.Output, entity.Fields);
return(entity);
}
public static string EntityOutputName(TflEntity entity, string processName)
{
return(entity.PrependProcessNameToOutputName ? String.Concat(processName.Replace("-", String.Empty), entity.Alias).Replace(" ", String.Empty) : entity.Alias);
}
public EntityBuilder(ProcessBuilder processBuilder, TflEntity entity)
{
_processBuilder = processBuilder;
_entity = entity;
}
