public bool VisitExprTableAlias(ExprTableAlias expr, TCtx arg)
{
var res = this.Visit(expr, "TableAlias", arg, out var argOut) && this.Accept("Alias", expr.Alias, argOut);
this._visitor.EndVisitExpr(expr, arg);
return(res);
}
public static ExprTableAlias WithAlias(this ExprTableAlias original, IExprAlias newAlias) => new ExprTableAlias(alias: newAlias);
public static ExprDerivedTableValues WithAlias(this ExprDerivedTableValues original, ExprTableAlias newAlias) => new ExprDerivedTableValues(values: original.Values, alias: newAlias, columns: original.Columns);
public static ExprDerivedTableQuery WithAlias(this ExprDerivedTableQuery original, ExprTableAlias newAlias) => new ExprDerivedTableQuery(query: original.Query, alias: newAlias, columns: original.Columns);
internal MergeDataBuilder(TTable table, IEnumerable <TItem> data, IExprAlias sourceTableAlias)
{
this._table = table;
this._data = data;
this._sourceTableAlias = new ExprTableAlias(sourceTableAlias);
}
public static ExprDerivedTableQuery As(this IExprSubQuery expressionBuilder, ExprTableAlias tableAlias) => new ExprDerivedTableQuery(expressionBuilder, tableAlias, null);
public MergerUpdateSetter(TTable target, ExprTableAlias sourceDataAlias) : base(target)
{
this.SourceDataAlias = sourceDataAlias;
}
public bool VisitExprTableAlias(ExprTableAlias tableAlias, IExpr?parent)
{
tableAlias.Alias.Accept(this, tableAlias);
return(true);
}
protected ExprDerivedTable(ExprTableAlias alias)
{
this.Alias = alias;
}
public ExprDerivedTableQuery(IExprSubQuery query, ExprTableAlias alias, IReadOnlyList <ExprColumnName>?columns) : base(alias)
{
this.Query = query;
this.Columns = columns;
}
public ExprDerivedTableValues(ExprTableValueConstructor values, ExprTableAlias alias, IReadOnlyList <ExprColumnName> columns) : base(alias)
{
this.Values = values;
this.Columns = columns;
}
public static UpdateDataAnalysis AnalyzeUpdateData <TTable, TItem>
(
IEnumerable <TItem> data,
TTable targetTable,
DataMapping <TTable, TItem> dataMapKeys,
DataMapping <TTable, TItem>?dataMap,
IndexDataMapping?extraDataMap,
ExprTableAlias sourceTableAlias
)
{
var records = data.TryToCheckLength(out var capacity)
? capacity > 0 ? new List <ExprValueRow>(capacity) : null
: new List <ExprValueRow>();
if (records == null)
{
throw new SqExpressException("Input data should not be empty");
}
DataMapSetter <TTable, TItem>? setter = null;
List <ExprColumnName>? keys = null;
IReadOnlyList <ExprColumnName>?allTableColumns = null;
IReadOnlyList <ExprColumnName>?totalColumns = null;
foreach (var item in data)
{
setter ??= new DataMapSetter <TTable, TItem>(targetTable, item);
setter.NextItem(item, totalColumns?.Count);
dataMapKeys(setter);
keys ??= new List <ExprColumnName>(setter.Columns);
keys.AssertNotEmpty("There should be at least one key");
dataMap?.Invoke(setter);
totalColumns = allTableColumns ??= new List <ExprColumnName>(setter.Columns);
if (extraDataMap != null)
{
extraDataMap.Invoke(setter);
if (ReferenceEquals(totalColumns, allTableColumns))
{
totalColumns = new List <ExprColumnName>(setter.Columns);
}
}
setter.EnsureRecordLength();
records.Add(new ExprValueRow(setter.Record.AssertFatalNotNull(nameof(setter.Record))));
}
if (records.Count < 1)
{
throw new SqExpressException("Input data should not be empty");
}
keys = keys.AssertFatalNotNull(nameof(keys));
allTableColumns = allTableColumns.AssertFatalNotNull(nameof(allTableColumns));
totalColumns = totalColumns.AssertFatalNotNull(nameof(allTableColumns));
var exprValuesTable = new ExprDerivedTableValues(new ExprTableValueConstructor(records), sourceTableAlias, totalColumns);
if (keys.Count > allTableColumns.Count)
{
throw new SqExpressException("The number of keys exceeds the number of columns");
}
return(new UpdateDataAnalysis(keys, allTableColumns, exprValuesTable));
}
