public SourceGraphSqlModel(SyncModel model, IShellContext context, DataSyncSqlModel dataSync)
{
_model = model;
if (!model.Sources.Any())
{
throw new IncorrectRdsDefinitionException("LGM-00000 There are no available sources entities. Try to add source.");
}
foreach (var item in model.Sources)
{
var src = new SourceEntitySqlModel(item, dataSync);
Entities.Add(src);
src.SqlAlias = item.Alias ?? "src_" + Entities.Count;
src.InitializeQuerySource(item.DataSource, context, context.Replace(item.SourceTableVariable), context.Replace(item.SourceQueryVariable));
src.MaterializeIfNeeded();
foreach (var colItem in item.Columns)
{
string alias = colItem.AliasOrName;
if (!Columns.ContainsKey(alias))
{
Columns[alias] = new SourceColumnSqlModel
{
Alias = alias,
};
}
Columns[alias].DbshColumns.Add(colItem);
Columns[alias].Entities.Add(src);
src.Columns.Add(Columns[alias]);
if (!String.IsNullOrEmpty(colItem.Filter))
{
Columns[alias].Filters.Add(colItem.Filter);
if (colItem.FilterType != Driver.Common.FilterParser.FilterParser.ExpressionType.None)
{
Columns[alias].FilterType = colItem.FilterType;
}
}
}
}
}
private FilterJoinSqlModel(SourceEntitySqlModel rootModel, SourceGraphSqlModel sourceGraphModel, IDatabaseFactory factory)
{
_sourceGraph = sourceGraphModel;
_rootEntity = rootModel;
_factory = factory;
FillEntitiesOnTheSameServer();
BuildLinkedEntities();
bool hasFilter = _linkedEntities.Any(x => x.Dbsh.Columns.Any(y => y.Filter != null));
if (!hasFilter)
{
_isValid = false;
return;
}
_filteredEntities.AddRange(_linkedEntities);
DetectUnusedEntities();
}
private string EntityAlias(SourceEntitySqlModel entity)
{
return "src_" + _filteredEntities.IndexOf(entity);
}
private NameWithSchema EntityFullName(SourceEntitySqlModel entity)
{
return EntityTable(entity).GetFullName(null);
}
private DbShell.Core.Utility.TableOrView EntityTable(SourceEntitySqlModel entity)
{
return (DbShell.Core.Utility.TableOrView)entity.Dbsh.DataSource;
}
public static FilterJoinSqlModel Create(SourceEntitySqlModel rootTable, SourceGraphSqlModel sourceGraphModel, IDatabaseFactory factory)
{
var res = new FilterJoinSqlModel(rootTable, sourceGraphModel, factory);
if (res._isValid) return res;
return null;
}
private void AddEntity(SourceEntitySqlModel sourceEntity)
{
var src = new SourceEntitySqlModel(sourceEntity.Dbsh, _sourceGraph.DataSync);
Entities.Add(src);
src.SqlAlias = sourceEntity.SqlAlias;
src.QuerySource = sourceEntity.QuerySource;
src.TableName = sourceEntity.TableName;
src.IsExternal = sourceEntity.IsExternal;
foreach (var colItem in sourceEntity.Dbsh.Columns)
{
string alias = colItem.AliasOrName;
if (!Columns.ContainsKey(alias))
{
Columns[alias] = new SourceColumnSqlModel
{
Alias = alias,
};
}
Columns[alias].DbshColumns.Add(colItem);
Columns[alias].Entities.Add(src);
Columns[alias].FilterType = colItem.FilterType;
if (!String.IsNullOrEmpty(colItem.Filter))
{
Columns[alias].Filters.Add(colItem.Filter);
}
src.Columns.Add(Columns[alias]);
}
}
private bool EntityHasKey(SourceEntitySqlModel entity)
{
return _targetEntitySqlModel.KeySourceColumns.Any(x => entity.Columns.Any(y => y.Alias == x.Alias));
//return _targetEntitySqlModel.TargetColumns.Where(x => x.IsKey).Any(x => x.Sources.Any(y => entity.Columns.Any(z => z.Alias == y.Alias)));
}
public SourceJoinSqlModel(TargetEntitySqlModel targetEntitySqlModel, SourceGraphSqlModel sourceGraph)
{
_targetEntitySqlModel = targetEntitySqlModel;
_sourceGraph = sourceGraph;
SourceToRefsJoin = new DmlfFromItem();
//foreach (var column in _targetEntitySqlModel.RequiredSourceColumns)
//{
// if (Columns.ContainsKey(column.Alias)) continue;
// Columns[column.Alias] = new SourceColumnSqlModel
// {
// Alias = column.Alias,
// };
// bool addedEntity = false;
// foreach (var ent in column.Entities)
// {
// if (ent.SingleKeyColumn == column.Alias)
// {
// AddEntity(ent);
// addedEntity = true;
// break;
// }
// }
// if (addedEntity) continue;
// AddEntity(column.Entities.First());
//}
if (_sourceGraph == null)
{
// flat variant
PrimarySource = _targetEntitySqlModel.DataSync.FlatSources.FirstOrDefault(x => x.Match(_targetEntitySqlModel.Dbsh.PrimarySource));
if (PrimarySource == null)
{
throw new IncorrectRdsDefinitionException($"DBSH-00000 Source not found for entity {_targetEntitySqlModel.LogName}");
}
SourceToRefsJoin.Source = PrimarySource.QuerySource;
foreach (var col in PrimarySource.Columns)
{
Columns[col.Alias] = col;
}
}
else
{
_entityQueue.AddRange(_sourceGraph.Entities);
DetectPrimarySource();
DetectUnusedEntities();
RebuildEntityList();
//queue.Add(_targetEntitySqlModel.KeySourceColumns.First().Entities.First());
//foreach (var ent in _targetEntitySqlModel.RequiredSourceColumns.SelectMany(x => x.Entities))
//{
// if (queue.Contains(ent)) continue;
// queue.Add(ent);
//}
if (!_entityQueue.Any() && targetEntitySqlModel.Dbsh.Columns.Any(x => x.IsKey))
{
throw new IncorrectRdsDefinitionException($"LGM-00000 None of source entities is used in {_targetEntitySqlModel.LogName} (try to set source column)");
}
if (_entityQueue.Any())
{
CreateSourceJoin();
AddRefsToJoin();
}
foreach (var col in Columns.Values) col.CompileFilter();
}
}
private void DetectPrimarySource()
{
PrimarySource = null;
if (!String.IsNullOrWhiteSpace(_targetEntitySqlModel.Dbsh.PrimarySource))
{
if (_sourceGraph != null)
{
PrimarySource = _sourceGraph.Entities.FirstOrDefault(x => x.Match(_targetEntitySqlModel.Dbsh.PrimarySource));
if (PrimarySource == null)
{
throw new Exception($"DBSH-00216 Primary source {_targetEntitySqlModel.Dbsh.PrimarySource} for target {_targetEntitySqlModel.TargetTable} not found");
}
}
}
else
{
foreach (var entity in _sourceGraph.Entities)
{
var keyColumns = entity.KeyColumns;
keyColumns = keyColumns.Where(x => x.Entities.Count == 1).ToList();
if (!keyColumns.Any()) continue;
if (_targetEntitySqlModel.KeySourceColumns.Any(x => keyColumns.Any(y => y.Alias == x.Alias)))
{
PrimarySource = entity;
// primary source is found
return;
}
}
}
}
public DataSyncSqlModel(SyncModel model, IShellContext context, bool allowExternalSources, string providerString)
{
_model = model;
_allowExternalSources = allowExternalSources;
foreach(var param in model.Parameters)
{
Parameters.Add(new ParameterModel
{
DataType = context.Replace(param.DataType),
DefaultValue = context.Replace(param.DefaultValue),
Name = context.Replace(param.Name),
});
}
ProviderString = providerString;
TargetStructure = context.GetDatabaseStructure(providerString);
if (_model.IsFlatSync)
{
foreach (var src in _model.Sources)
{
var entity = new SourceEntitySqlModel(src, this);
entity.LoadFlatColumns();
FlatSources.Add(entity);
entity.SqlAlias = src.Alias ?? "src_" + FlatSources.Count;
entity.InitializeQuerySource(src.DataSource, context, src.SourceTableVariable, src.SourceQueryVariable);
entity.MaterializeIfNeeded();
}
}
else
{
SourceGraphModel = new SourceGraphSqlModel(model, context, this);
foreach(var col in SourceGraphModel.Columns.Values)
{
col.CompileFilter();
}
}
foreach (var entity in model.Targets)
{
Entities.Add(new TargetEntitySqlModel(this, entity, context));
}
foreach (var fk in model.TargetReferences)
{
var sourceReplaced = context.Replace(fk.Source);
var sourceEntity = FindTarget(sourceReplaced);
string targetReplaced = context.Replace(fk.Target);
var targetEntity = FindTarget(targetReplaced);
if (sourceEntity == null) throw new Exception($"DBSH-00000 Source entity {sourceReplaced} not found");
if (targetEntity == null) throw new Exception($"DBSH-00219 Target entity {targetReplaced} not found");
sourceEntity.AddReference(fk, targetEntity);
}
PartialSortEntitiesByRefs();
foreach (var entity in Entities)
{
entity.CreateJoinModel();
}
foreach (var entity in Entities)
{
entity.TestCorrectness();
}
}
//private void RunScript(DbConnection conn, IDatabaseFactory factory, Action<SqlScriptCompiler> prolog, Action<SqlScriptCompiler> epilog, IShellContext context, string procname, bool useTransaction)
//{
// var cmp = new SqlScriptCompiler(factory, this, context, name.ToString());
// var sw = new StringWriter();
// var so = new SqlOutputStream(factory.CreateDialect(), sw, new SqlFormatProperties());
// so.OverrideCommandDelimiter(";");
// var dmp = factory.CreateDumper(so, new SqlFormatProperties());
// var cmp = new SqlScriptCompiler(dmp, this, context, procname);
// if (prolog != null) prolog(cmp);
// DumpScript(cmp, useTransaction);
// if (epilog != null) epilog(cmp);
// using (var cmd = conn.CreateCommand())
// {
// cmd.CommandText = sw.ToString();
// cmd.ExecuteNonQuery();
// }
//}
public void AddExternalSource(SourceEntitySqlModel sourceEntity)
{
if (!_allowExternalSources) throw new Exception("DBSH-00214 External sources not supported in this context");
_externalSources.Add(sourceEntity);
}
