public void ExecuteDeleteTest()
{
int? id = null;
ISqlObject source = new SqlServerSource(TABLE_NAME);
DbConnection connection = new SqlConnection(Properties.Settings.Default.SqlConnectionString);
try {
ISqlSelectStatement identityStatement = new SqlServerSelectStatement();
identityStatement.SelectClause.AddExpressions(new SqlFunction("IDENT_CURRENT").AddArgument(new SqlServerExpressionFactory().ConstantFactory.Create(TABLE_NAME)));
ISqlObject nameField = new SqlServerField(source, "Name", null);
ISqlExpression name = SqlStringExpression.FromParameter(new SqlParameter("@name", "Insert Test"));
ISqlInsertStatement insertStatement = new SqlInsertStatement();
insertStatement.FieldValueClause.SetSource(source).AddField(nameField, name);
id = SqlHelper.ExecuteInsert(connection, insertStatement, identityStatement);
} finally {
if (id.HasValue)
{
ISqlDeleteStatement deleteStatement = new SqlDeleteStatement();
deleteStatement.FromClause.Source = source;
deleteStatement.WhereClause.Condition = new SqlServerField(source, "ID", null).Equal(SqlStringExpression.FromParameter(new SqlParameter("@ID", id.Value)));
SqlHelper.ExecuteDelete(connection, deleteStatement);
}
}
}
public virtual void Visiting(SqlInsertStatement insertStatement)
{
insertStatement.SqlInsertClause.Accept(this);
if (insertStatement.DefaultValues)
{
sqlBuilder.Append(" Default Values");
}
else
{
if (insertStatement.SqlColumnList.Count > 0)
{
sqlBuilder.Append(" (");
foreach (SqlColumn sqlColumn in insertStatement.SqlColumnList)
{
sqlColumn.Accept(this);
sqlBuilder.Append(", ");
}
sqlBuilder.Length -= 2;
sqlBuilder.Append(") Values (");
foreach (SqlExpression sqlExpression in insertStatement.ValueList)
{
sqlExpression.Accept(this);
sqlBuilder.Append(", ");
}
sqlBuilder.Length -= 2;
sqlBuilder.Append(")");
}
}
}
public static void MakeAlternativeInsertOrUpdate(Query query)
{
var dic = new Dictionary <ICloneableElement, ICloneableElement>();
var firstStatement = (SqlInsertOrUpdateStatement)query.Queries[0].Statement;
var cloned = (SqlInsertOrUpdateStatement)firstStatement.Clone(dic, _ => true);
var insertStatement = new SqlInsertStatement(cloned.SelectQuery)
{
Insert = cloned.Insert
};
insertStatement.SelectQuery.From.Tables.Clear();
query.Queries.Add(new QueryInfo
{
Statement = insertStatement,
Parameters = query.Queries[0].Parameters
.Select(p => new ParameterAccessor
(
p.Expression,
p.Accessor,
p.DataTypeAccessor,
p.DbTypeAccessor,
dic.ContainsKey(p.SqlParameter) ? (SqlParameter)dic[p.SqlParameter] : null
))
.Where(p => p.SqlParameter != null)
.ToList(),
});
var keys = firstStatement.Update.Keys;
foreach (var key in keys)
{
firstStatement.SelectQuery.Where.Expr(key.Column).Equal.Expr(key.Expression);
}
//TODO! looks not working solution
if (firstStatement.Update.Items.Count > 0)
{
query.Queries[0].Statement = new SqlUpdateStatement(firstStatement.SelectQuery)
{
Update = firstStatement.Update
};
SetNonQueryQuery2(query);
}
else
{
firstStatement.SelectQuery.Select.Columns.Clear();
firstStatement.SelectQuery.Select.Columns.Add(new SqlColumn(firstStatement.SelectQuery, new SqlExpression("1")));
query.Queries[0].Statement = new SqlSelectStatement(firstStatement.SelectQuery);
SetQueryQuery2(query);
}
query.Queries.Add(new QueryInfo
{
Statement = new SqlSelectStatement(firstStatement.SelectQuery),
Parameters = query.Queries[0].Parameters.ToList(),
});
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var isSubQuery = sequence.SelectQuery.Select.IsDistinct;
if (isSubQuery)
{
sequence = new SubQueryContext(sequence);
}
if (!(sequence.Statement is SqlInsertStatement insertStatement))
{
insertStatement = new SqlInsertStatement(sequence.SelectQuery);
sequence.Statement = insertStatement;
}
var insertType = InsertContext.InsertType.Insert;
switch (methodCall.Method.Name)
{
case nameof(LinqExtensions.Insert): insertType = InsertContext.InsertType.Insert; break;
case nameof(LinqExtensions.InsertWithIdentity): insertType = InsertContext.InsertType.InsertWithIdentity; break;
case nameof(LinqExtensions.InsertWithOutput): insertType = InsertContext.InsertType.InsertOutput; break;
case nameof(LinqExtensions.InsertWithOutputInto): insertType = InsertContext.InsertType.InsertOutputInto; break;
}
/// <summary>
/// This is internal API and is not intended for use by Linq To DB applications.
/// It may change or be removed without further notice.
/// </summary>
public static SqlInsertClause?GetInsertClause(this SqlStatement statement)
{
return(statement switch
{
SqlInsertStatement insert => insert.Insert,
SqlInsertOrUpdateStatement update => update.Insert,
_ => null,
});
static Query <object> CreateQuery(
IDataContext dataContext,
EntityDescriptor descriptor,
[DisallowNull] T obj,
InsertColumnFilter <T>?columnFilter,
string?tableName,
string?serverName,
string?databaseName,
string?schemaName,
TableOptions tableOptions,
Type type)
{
var sqlTable = new SqlTable(dataContext.MappingSchema, type);
if (tableName != null)
{
sqlTable.PhysicalName = tableName;
}
if (serverName != null)
{
sqlTable.Server = serverName;
}
if (databaseName != null)
{
sqlTable.Database = databaseName;
}
if (schemaName != null)
{
sqlTable.Schema = schemaName;
}
if (tableOptions.IsSet())
{
sqlTable.TableOptions = tableOptions;
}
var sqlQuery = new SelectQuery();
var insertStatement = new SqlInsertStatement(sqlQuery)
{
Insert = { Into = sqlTable, WithIdentity = true }
};
var ei = new Query <object>(dataContext, null)
{
Queries = { new QueryInfo {
Statement = insertStatement,
} }
};
foreach (var field in sqlTable.Fields.Where(x => columnFilter == null || columnFilter(obj, x.ColumnDescriptor)))
{
if (field.IsInsertable && !field.ColumnDescriptor.ShouldSkip(obj !, descriptor, SkipModification.Insert))
{
var param = GetParameter(type, dataContext, field);
ei.Queries[0].Parameters.Add(param);
insertStatement.Insert.Items.Add(new SqlSetExpression(field, param.SqlParameter));
}
static Query <object> CreateQuery(IDataContext dataContext, string tableName, string databaseName, string schemaName, Type type)
{
var sqlTable = new SqlTable(dataContext.MappingSchema, type);
if (tableName != null)
{
sqlTable.PhysicalName = tableName;
}
if (databaseName != null)
{
sqlTable.Database = databaseName;
}
if (schemaName != null)
{
sqlTable.Schema = schemaName;
}
var sqlQuery = new SelectQuery();
var insertStatement = new SqlInsertStatement(sqlQuery);
insertStatement.Insert.Into = sqlTable;
insertStatement.Insert.WithIdentity = true;
var ei = new Query <object>(dataContext, null)
{
Queries = { new QueryInfo {
Statement = insertStatement,
} }
};
foreach (var field in sqlTable.Fields)
{
if (field.Value.IsInsertable)
{
var param = GetParameter(type, dataContext, field.Value);
ei.Queries[0].Parameters.Add(param);
insertStatement.Insert.Items.Add(new SqlSetExpression(field.Value, param.SqlParameter));
}
else if (field.Value.IsIdentity)
{
var sqlb = dataContext.CreateSqlProvider();
var expr = sqlb.GetIdentityExpression(sqlTable);
if (expr != null)
{
insertStatement.Insert.Items.Add(new SqlSetExpression(field.Value, expr));
}
}
}
SetScalarQuery(ei);
return(ei);
}
static Query <int> CreateQuery(IDataContext dataContext, EntityDescriptor descriptor, T obj, string tableName, string databaseName, string schemaName, Type type)
{
var sqlTable = new SqlTable(dataContext.MappingSchema, type);
if (tableName != null)
{
sqlTable.PhysicalName = tableName;
}
if (databaseName != null)
{
sqlTable.Database = databaseName;
}
if (schemaName != null)
{
sqlTable.Schema = schemaName;
}
var insertStatement = new SqlInsertStatement {
Insert = { Into = sqlTable }
};
var ei = new Query <int>(dataContext, null)
{
Queries = { new QueryInfo {
Statement = insertStatement
} }
};
foreach (var field in sqlTable.Fields)
{
if (field.Value.IsInsertable && !field.Value.ColumnDescriptor.ShouldSkip(obj, descriptor, SkipModification.Insert))
{
var param = GetParameter(type, dataContext, field.Value);
ei.Queries[0].Parameters.Add(param);
insertStatement.Insert.Items.Add(new SqlSetExpression(field.Value, param.SqlParameter));
}
else if (field.Value.IsIdentity)
{
var sqlb = dataContext.CreateSqlProvider();
var expr = sqlb.GetIdentityExpression(sqlTable);
if (expr != null)
{
insertStatement.Insert.Items.Add(new SqlSetExpression(field.Value, expr));
}
}
}
SetNonQueryQuery(ei);
return(ei);
}
public void SqlStringTest()
{
ISqlObject source = new SqlServerSource("Table");
ISqlObject field0 = new SqlServerField(source, "ID", null);
ISqlExpression value0 = new SqlStringExpression("13");
ISqlObject field1 = new SqlServerField(source, "Type", null);
ISqlExpression value1 = new SqlStringExpression("14");
ISqlInsertStatement statement = new SqlInsertStatement();
statement.FieldValueClause.SetSource(source).AddField(field0, value0).AddField(field1, value1);
Assert.AreEqual <string>(string.Format("{0} {1}", statement.Keyword, statement.FieldValueClause.SqlString),
statement.SqlString);
}
static Query <int> CreateQuery(
IDataContext dataContext,
EntityDescriptor descriptor,
T obj,
InsertColumnFilter <T>?columnFilter,
string?tableName,
string?serverName,
string?databaseName,
string?schemaName,
TableOptions tableOptions,
Type type)
{
var sqlTable = new SqlTable(dataContext.MappingSchema, type);
if (tableName != null || schemaName != null || databaseName != null || databaseName != null)
{
sqlTable.TableName = new(
tableName ?? sqlTable.TableName.Name,
Server : serverName ?? sqlTable.TableName.Server,
Database : databaseName ?? sqlTable.TableName.Database,
Schema : schemaName ?? sqlTable.TableName.Schema);
}
if (tableOptions.IsSet())
{
sqlTable.TableOptions = tableOptions;
}
var insertStatement = new SqlInsertStatement {
Insert = { Into = sqlTable }
};
var ei = new Query <int>(dataContext, null)
{
Queries = { new QueryInfo {
Statement = insertStatement
} }
};
foreach (var field in sqlTable.Fields.Where(x => columnFilter == null || columnFilter(obj, x.ColumnDescriptor)))
{
if (field.IsInsertable && !field.ColumnDescriptor.ShouldSkip(obj !, descriptor, SkipModification.Insert))
{
var param = GetParameter(type, dataContext, field);
ei.Queries[0].AddParameterAccessor(param);
insertStatement.Insert.Items.Add(new SqlSetExpression(field, param.SqlParameter));
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var extract = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var update = methodCall.Arguments[2].Unwrap();
if (!(sequence.Statement is SqlInsertStatement insertStatement))
{
insertStatement = new SqlInsertStatement(sequence.SelectQuery);
sequence.Statement = insertStatement;
}
if (insertStatement.Insert.Into == null)
{
insertStatement.Insert.Into = (SqlTable)sequence.SelectQuery.From.Tables[0].Source;
insertStatement.SelectQuery.From.Tables.Clear();
}
if (update.NodeType == ExpressionType.Lambda)
{
var fieldsContext = new TableBuilder.TableContext(builder, new SelectQuery(), insertStatement.Insert.Into);
UpdateBuilder.ParseSet(
builder,
buildInfo,
extract,
(LambdaExpression)update,
fieldsContext,
sequence,
insertStatement.Insert.Into,
insertStatement.Insert.Items);
}
else
{
UpdateBuilder.ParseSet(
builder,
extract,
methodCall,
2,
sequence,
insertStatement.Insert.Items);
}
insertStatement.Insert.Items.RemoveDuplicatesFromTail((s1, s2) => s1.Column.Equals(s2.Column));
return(sequence);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var source = methodCall.Arguments[0].Unwrap();
var into = methodCall.Arguments[1].Unwrap();
IBuildContext sequence;
SqlInsertStatement insertStatement;
// static IValueInsertable<T> Into<T>(this IDataContext dataContext, Table<T> target)
//
if (source.NodeType == ExpressionType.Constant && ((ConstantExpression)source).Value == null)
{
sequence = builder.BuildSequence(new BuildInfo((IBuildContext?)null, into, new SelectQuery()));
if (sequence.SelectQuery.Select.IsDistinct)
{
sequence = new SubQueryContext(sequence);
}
insertStatement = new SqlInsertStatement(sequence.SelectQuery);
insertStatement.Insert.Into = ((TableBuilder.TableContext)sequence).SqlTable;
insertStatement.SelectQuery.From.Tables.Clear();
}
// static ISelectInsertable<TSource,TTarget> Into<TSource,TTarget>(this IQueryable<TSource> source, Table<TTarget> target)
//
else
{
sequence = builder.BuildSequence(new BuildInfo(buildInfo, source));
if (sequence.SelectQuery.Select.IsDistinct)
{
sequence = new SubQueryContext(sequence);
}
insertStatement = new SqlInsertStatement(sequence.SelectQuery);
var tbl = builder.BuildSequence(new BuildInfo((IBuildContext?)null, into, new SelectQuery()));
insertStatement.Insert.Into = ((TableBuilder.TableContext)tbl).SqlTable;
}
sequence.Statement = insertStatement;
sequence.SelectQuery.Select.Columns.Clear();
return(sequence);
}
public void StatementAsExpected()
{
var dataType = "SqlUnitTestObject1";
var createdTimeUtc = DateTime.Parse("2019-08-27 01:02:03");
var container = new GenericDataContainer(
"1234",
"jdoe",
createdTimeUtc,
"jdoe",
createdTimeUtc,
ApiVersion.Current,
DataEncoder.Encode(JsonConvert.SerializeObject(new { Name = "Doe", Age = 101.4, TimeUtc = createdTimeUtc })));
var actual = SqlInsertStatement.CreateFromContainer(dataType, container);
var expected = $"INSERT INTO {dataType} (Id, OriginalSubmitter, CreatedTimeUtc, Submitter, SubmissionTimeUtc, Data#Name, Data#Age, Data#TimeUtc) "
+ "VALUES ('1234', 'jdoe', '2019-08-27 01:02:03', 'jdoe', '2019-08-27 01:02:03', 'Doe', '101.4', '2019-08-27 01:02:03')";
Assert.That(actual, Is.EqualTo(expected));
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var extract = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var update = methodCall.Arguments[2].Unwrap();
if (!(sequence.Statement is SqlInsertStatement insertStatement))
{
insertStatement = new SqlInsertStatement(sequence.SelectQuery);
sequence.Statement = insertStatement;
}
if (insertStatement.Insert.Into == null)
{
insertStatement.Insert.Into = (SqlTable)sequence.SelectQuery.From.Tables[0].Source;
insertStatement.SelectQuery.From.Tables.Clear();
}
if (update.NodeType == ExpressionType.Lambda)
{
UpdateBuilder.ParseSet(
builder,
buildInfo,
extract,
(LambdaExpression)update,
sequence,
insertStatement.Insert.Into,
insertStatement.Insert.Items);
}
else
{
UpdateBuilder.ParseSet(
builder,
buildInfo,
extract,
update,
sequence,
insertStatement.Insert.Items);
}
return(sequence);
}
public void Execute(Dictionary <string, Table> tables, SqlInsertStatement insertStatement)
{
var spec = insertStatement.Children.First( ) as SqlInsertSpecification;
var table = GetInsertTable(tables, spec);
var columns = GetInsertColumns(spec, table);
switch (spec.Source)
{
case SqlTableConstructorInsertSource tableSource:
AddRowFromTableConstructor(table, columns, tableSource);
break;
case SqlSelectSpecificationInsertSource selectSource:
AddRowsFromSelect(table, columns, selectSource);
break;
default:
throw new NotImplementedException($"Not implemented for insert source {spec.Source.GetType( ) }");
}
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var isSubQuery = sequence.SelectQuery.Select.IsDistinct;
if (isSubQuery)
{
sequence = new SubQueryContext(sequence);
}
if (!(sequence.Statement is SqlInsertStatement insertStatement))
{
insertStatement = new SqlInsertStatement(sequence.SelectQuery);
sequence.Statement = insertStatement;
}
var insertType = InsertContext.InsertType.Insert;
switch (methodCall.Method.Name)
{
case "Insert": insertType = InsertContext.InsertType.Insert; break;
case "InsertWithIdentity": insertType = InsertContext.InsertType.InsertWithIdentity; break;
case "InsertWithOutput": insertType = InsertContext.InsertType.InsertOutput; break;
case "InsertWithOutputInto": insertType = InsertContext.InsertType.InsertOutputInto; break;
}
var indexedParameters
= methodCall.Method.GetParameters().Select((p, i) => Tuple.Create(p, i)).ToDictionary(t => t.Item1.Name, t => t.Item2);
Expression GetArgumentByName(string name)
{
return(methodCall.Arguments[indexedParameters[name]]);
}
LambdaExpression GetOutputExpression(Type outputType)
{
if (!indexedParameters.TryGetValue("outputExpression", out var index))
{
var param = Expression.Parameter(outputType);
return(Expression.Lambda(param, param));
}
return((LambdaExpression)methodCall.Arguments[index].Unwrap());
}
IBuildContext? outputContext = null;
LambdaExpression?outputExpression = null;
if (methodCall.Arguments.Count > 0)
{
var argument = methodCall.Arguments[0];
if (typeof(IValueInsertable <>).IsSameOrParentOf(argument.Type) ||
typeof(ISelectInsertable <,>).IsSameOrParentOf(argument.Type))
{
// static int Insert<T> (this IValueInsertable<T> source)
// static int Insert<TSource,TTarget>(this ISelectInsertable<TSource,TTarget> source)
sequence.SelectQuery.Select.Columns.Clear();
foreach (var item in insertStatement.Insert.Items)
{
sequence.SelectQuery.Select.ExprNew(item.Expression !);
}
}
else if (methodCall.Arguments.Count > 1 &&
typeof(IQueryable <>).IsSameOrParentOf(argument.Type) &&
typeof(ITable <>).IsSameOrParentOf(methodCall.Arguments[1].Type))
{
// static int Insert<TSource,TTarget>(this IQueryable<TSource> source, Table<TTarget> target, Expression<Func<TSource,TTarget>> setter)
var into = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SelectQuery()));
var setter = (LambdaExpression)GetArgumentByName("setter").Unwrap();
UpdateBuilder.BuildSetter(
builder,
buildInfo,
setter,
into,
insertStatement.Insert.Items,
sequence);
sequence.SelectQuery.Select.Columns.Clear();
foreach (var item in insertStatement.Insert.Items)
{
sequence.SelectQuery.Select.Columns.Add(new SqlColumn(sequence.SelectQuery, item.Expression !));
}
insertStatement.Insert.Into = ((TableBuilder.TableContext)into).SqlTable;
}
else if (typeof(ITable <>).IsSameOrParentOf(argument.Type))
{
// static int Insert<T>(this Table<T> target, Expression<Func<T>> setter)
// static TTarget InsertWithOutput<TTarget>(this ITable<TTarget> target, Expression<Func<TTarget>> setter)
// static TTarget InsertWithOutput<TTarget>(this ITable<TTarget> target, Expression<Func<TTarget>> setter, Expression<Func<TTarget,TOutput>> outputExpression)
var argIndex = 1;
var arg = methodCall.Arguments[argIndex].Unwrap();
LambdaExpression?setter = null;
switch (arg)
{
case LambdaExpression lambda:
{
setter = lambda;
UpdateBuilder.BuildSetter(
builder,
buildInfo,
setter,
sequence,
insertStatement.Insert.Items,
sequence);
break;
}
default:
{
var objType = arg.Type;
var ed = builder.MappingSchema.GetEntityDescriptor(objType);
var into = sequence;
var ctx = new TableBuilder.TableContext(builder, buildInfo, objType);
var table = new SqlTable(objType);
foreach (ColumnDescriptor c in ed.Columns.Where(c => !c.SkipOnInsert))
{
if (!table.Fields.TryGetValue(c.ColumnName, out var field))
{
continue;
}
var pe = Expression.MakeMemberAccess(arg, c.MemberInfo);
var column = into.ConvertToSql(pe, 1, ConvertFlags.Field);
var parameter = builder.BuildParameterFromArgumentProperty(methodCall, argIndex, field.ColumnDescriptor);
insertStatement.Insert.Items.Add(new SqlSetExpression(column[0].Sql, parameter.SqlParameter));
}
var insertedTable = SqlTable.Inserted(methodCall.Method.GetGenericArguments()[0]);
break;
}
}
insertStatement.Insert.Into = ((TableBuilder.TableContext)sequence).SqlTable;
sequence.SelectQuery.From.Tables.Clear();
}
if (insertType == InsertContext.InsertType.InsertOutput || insertType == InsertContext.InsertType.InsertOutputInto)
{
outputExpression = GetOutputExpression(methodCall.Method.GetGenericArguments().Last());
insertStatement.Output = new SqlOutputClause();
var insertedTable = SqlTable.Inserted(outputExpression.Parameters[0].Type);
outputContext = new TableBuilder.TableContext(builder, new SelectQuery(), insertedTable);
insertStatement.Output.InsertedTable = insertedTable;
if (insertType == InsertContext.InsertType.InsertOutputInto)
{
var outputTable = GetArgumentByName("outputTable");
var destination = builder.BuildSequence(new BuildInfo(buildInfo, outputTable, new SelectQuery()));
UpdateBuilder.BuildSetter(
builder,
buildInfo,
outputExpression,
destination,
insertStatement.Output.OutputItems,
outputContext);
insertStatement.Output.OutputTable = ((TableBuilder.TableContext)destination).SqlTable;
}
}
}
var insert = insertStatement.Insert;
var q = insert.Into !.Fields.Values
.Except(insert.Items.Select(e => e.Column))
.OfType <SqlField>()
.Where(f => f.IsIdentity);
foreach (var field in q)
{
var expr = builder.DataContext.CreateSqlProvider().GetIdentityExpression(insert.Into);
if (expr != null)
{
insert.Items.Insert(0, new SqlSetExpression(field, expr));
if (methodCall.Arguments.Count == 3)
{
sequence.SelectQuery.Select.Columns.Insert(0, new SqlColumn(sequence.SelectQuery, insert.Items[0].Expression !));
}
}
}
insertStatement.Insert.WithIdentity = insertType == InsertContext.InsertType.InsertWithIdentity;
sequence.Statement = insertStatement;
if (insertType == InsertContext.InsertType.InsertOutput)
{
return(new InsertWithOutputContext(buildInfo.Parent, sequence, outputContext !, outputExpression !));
}
return(new InsertContext(buildInfo.Parent, sequence, insertType, outputExpression));
}
public override void Visit(SqlInsertStatement codeObject)
{
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var isSubQuery = sequence.SelectQuery.Select.IsDistinct;
if (isSubQuery)
{
sequence = new SubQueryContext(sequence);
}
if (!(sequence.Statement is SqlInsertStatement insertStatement))
{
insertStatement = new SqlInsertStatement(sequence.SelectQuery);
sequence.Statement = insertStatement;
}
switch (methodCall.Arguments.Count)
{
case 1:
// static int Insert<T> (this IValueInsertable<T> source)
// static int Insert<TSource,TTarget>(this ISelectInsertable<TSource,TTarget> source)
{
foreach (var item in insertStatement.Insert.Items)
{
sequence.SelectQuery.Select.Expr(item.Expression);
}
break;
}
case 2: // static int Insert<T>(this Table<T> target, Expression<Func<T>> setter)
{
UpdateBuilder.BuildSetter(
builder,
buildInfo,
(LambdaExpression)methodCall.Arguments[1].Unwrap(),
sequence,
insertStatement.Insert.Items,
sequence);
insertStatement.Insert.Into = ((TableBuilder.TableContext)sequence).SqlTable;
sequence.SelectQuery.From.Tables.Clear();
break;
}
case 3: // static int Insert<TSource,TTarget>(this IQueryable<TSource> source, Table<TTarget> target, Expression<Func<TSource,TTarget>> setter)
{
var into = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SelectQuery()));
UpdateBuilder.BuildSetter(
builder,
buildInfo,
(LambdaExpression)methodCall.Arguments[2].Unwrap(),
into,
insertStatement.Insert.Items,
sequence);
sequence.SelectQuery.Select.Columns.Clear();
foreach (var item in insertStatement.Insert.Items)
{
sequence.SelectQuery.Select.Columns.Add(new SqlColumn(sequence.SelectQuery, item.Expression));
}
insertStatement.Insert.Into = ((TableBuilder.TableContext)into).SqlTable;
break;
}
}
var insert = insertStatement.Insert;
var q = insert.Into.Fields.Values
.Except(insert.Items.Select(e => e.Column))
.OfType <SqlField>()
.Where(f => f.IsIdentity);
foreach (var field in q)
{
var expr = builder.DataContext.CreateSqlProvider().GetIdentityExpression(insert.Into);
if (expr != null)
{
insert.Items.Insert(0, new SqlSetExpression(field, expr));
if (methodCall.Arguments.Count == 3)
{
sequence.SelectQuery.Select.Columns.Insert(0, new SqlColumn(sequence.SelectQuery, insert.Items[0].Expression));
}
}
}
insertStatement.Insert.WithIdentity = methodCall.Method.Name == "InsertWithIdentity";
sequence.Statement = insertStatement;
return(new InsertContext(buildInfo.Parent, sequence, insertStatement.Insert.WithIdentity));
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var source = methodCall.Arguments[0].Unwrap();
var into = methodCall.Arguments[1].Unwrap();
IBuildContext sequence;
IBuildContext destinationSequence;
SqlInsertStatement insertStatement;
// static IValueInsertable<T> Into<T>(this IDataContext dataContext, Table<T> target)
//
if (source.NodeType == ExpressionType.Constant && ((ConstantExpression)source).Value == null)
{
sequence = builder.BuildSequence(new BuildInfo((IBuildContext?)null, into, new SelectQuery()));
destinationSequence = sequence;
if (sequence.SelectQuery.Select.IsDistinct)
{
sequence = new SubQueryContext(sequence);
}
insertStatement = new SqlInsertStatement(sequence.SelectQuery);
insertStatement.Insert.Into = ((TableBuilder.TableContext)sequence).SqlTable;
insertStatement.SelectQuery.From.Tables.Clear();
}
// static ISelectInsertable<TSource,TTarget> Into<TSource,TTarget>(this IQueryable<TSource> source, Table<TTarget> target)
//
else
{
sequence = builder.BuildSequence(new BuildInfo(buildInfo, source));
destinationSequence = builder.BuildSequence(new BuildInfo((IBuildContext?)null, into, new SelectQuery()));
if (sequence.SelectQuery.Select.IsDistinct)
{
sequence = new SubQueryContext(sequence);
}
var destinationTable = ((TableBuilder.TableContext)destinationSequence).SqlTable;
insertStatement = new SqlInsertStatement(sequence.SelectQuery);
insertStatement.Insert.Into = destinationTable;
}
// generating default items
var matched = MatchSequences(sequence, destinationSequence);
foreach (var tuple in matched)
{
var field = QueryHelper.GetUnderlyingField(tuple.Item2.Sql);
if (field == null || field.ColumnDescriptor.SkipOnInsert)
{
continue;
}
insertStatement.Insert.DefaultItems.Add(new SqlSetExpression(field, tuple.Item1.Sql));
}
sequence.Statement = insertStatement;
sequence.SelectQuery.Select.Columns.Clear();
return(sequence);
}
public virtual void Visited(SqlInsertStatement insertStatement)
{
}
public SqlInsertStatementFormatter(FormatterVisitor visitor, SqlInsertStatement codeObject)
: base(visitor, codeObject, false)
{
}
