private void GenerateFromSql(FromSqlExpression fromSqlExpression)
{
var sql = fromSqlExpression.Sql;
string[] substitutions = null;
switch (fromSqlExpression.Arguments)
{
case ConstantExpression constantExpression
when constantExpression.Value is CompositeRelationalParameter compositeRelationalParameter:
{
var subParameters = compositeRelationalParameter.RelationalParameters;
substitutions = new string[subParameters.Count];
for (var i = 0; i < subParameters.Count; i++)
{
substitutions[i] = _sqlGenerationHelper.GenerateParameterNamePlaceholder(subParameters[i].InvariantName);
}
_relationalCommandBuilder.AddParameter(compositeRelationalParameter);
break;
}
}
if (substitutions != null)
{
// ReSharper disable once CoVariantArrayConversion
// InvariantCulture not needed since substitutions are all strings
sql = string.Format(sql, substitutions);
}
_relationalCommandBuilder.AppendLines(sql);
}
private void GenerateFromSql(FromSqlExpression fromSqlExpression)
{
var sql = fromSqlExpression.Sql;
string[] substitutions = null;
switch (fromSqlExpression.Arguments)
{
case ConstantExpression constantExpression
when constantExpression.Value is CompositeRelationalParameter compositeRelationalParameter:
{
var subParameters = compositeRelationalParameter.RelationalParameters;
substitutions = new string[subParameters.Count];
for (var i = 0; i < subParameters.Count; i++)
{
substitutions[i] = _sqlGenerationHelper.GenerateParameterNamePlaceholder(subParameters[i].InvariantName);
}
_relationalCommandBuilder.AddParameter(compositeRelationalParameter);
break;
}
case ConstantExpression constantExpression
when constantExpression.Value is object[] constantValues:
{
substitutions = new string[constantValues.Length];
for (var i = 0; i < constantValues.Length; i++)
{
var value = constantValues[i];
if (value is RawRelationalParameter rawRelationalParameter)
{
substitutions[i] = _sqlGenerationHelper.GenerateParameterNamePlaceholder(rawRelationalParameter.InvariantName);
_relationalCommandBuilder.AddParameter(rawRelationalParameter);
}
else if (value is SqlConstantExpression sqlConstantExpression)
{
substitutions[i] = sqlConstantExpression.TypeMapping.GenerateSqlLiteral(sqlConstantExpression.Value);
}
}
break;
}
}
if (substitutions != null)
{
// ReSharper disable once CoVariantArrayConversion
// InvariantCulture not needed since substitutions are all strings
#pragma warning disable CA1305 // Specify IFormatProvider
sql = string.Format(sql, substitutions);
#pragma warning restore CA1305 // Specify IFormatProvider
}
_relationalCommandBuilder.AppendLines(sql);
}
public static IRelationalCommandBuilder AppendParameter(
[NotNull] this IRelationalCommandBuilder commandBuilder,
[NotNull] string name,
[CanBeNull] object value,
[NotNull] Type type,
[NotNull] string invariantName)
{
Check.NotNull(commandBuilder, nameof(commandBuilder));
Check.NotEmpty(name, nameof(name));
Check.NotNull(type, nameof(type));
bool?isNullable = null;
if (type.IsNullableType())
{
isNullable = true;
type = type.UnwrapNullableType();
}
commandBuilder.AddParameter(
name,
value,
t => t.GetMapping(type),
isNullable,
invariantName);
commandBuilder.Instance.Append(name);
return(commandBuilder);
}
protected virtual Expression VisitAsOfTable(TemporalTableExpression tableExpression)
{
// This method was modeled on "SqlServerQuerySqlGenerator.VisitTable".
// Where we deviate, is after printing the table name, we check if temporal constraints
// need to be applied.
Sql.Append(_sqlGenerationHelper.DelimitIdentifier(tableExpression.Name, tableExpression.Schema));
if (tableExpression.AsOfDate != null)
{
var name = TEMPORAL_PARAMETER_PREFIX + tableExpression.AsOfDate.Name;
Sql.Append($" FOR SYSTEM_TIME AS OF @{name}"); //2020-02-28T11:00:00
if (!_commandbuilder.Parameters.Any(x => x.InvariantName == tableExpression.AsOfDate.Name))
{
_commandbuilder.AddParameter(tableExpression.AsOfDate.Name, name);
}
}
Sql
.Append(AliasSeparator)
.Append(_sqlGenerationHelper.DelimitIdentifier(tableExpression.Alias));
return(tableExpression);
}
protected override OeAsyncEnumerator ExecuteScalar(Object dataContext, String sql, IReadOnlyList <KeyValuePair <String, Object> > parameters, Type returnType)
{
var dbContext = (DbContext)dataContext;
var connection = dbContext.GetService <IRelationalConnection>();
var commandBuilderFactory = dbContext.GetService <IRelationalCommandBuilderFactory>();
IRelationalCommandBuilder commandBuilder = commandBuilderFactory.Create();
commandBuilder.Append(sql);
var parameterNameGenerator = dbContext.GetService <IParameterNameGeneratorFactory>().Create();
var sqlHelper = dbContext.GetService <ISqlGenerationHelper>();
var parameterValues = new Dictionary <String, Object>(parameters.Count);
for (int i = 0; i < parameters.Count; i++)
{
String invariantName = parameterNameGenerator.GenerateNext();
String name = sqlHelper.GenerateParameterName(invariantName);
commandBuilder.AddParameter(invariantName, name);
parameterValues.Add(invariantName, parameters[i].Value);
}
IRelationalCommand command = commandBuilder.Build();
Task <Object> scalarTask = command.ExecuteScalarAsync(connection, parameterValues);
return(new OeScalarAsyncEnumeratorAdapter(scalarTask, CancellationToken.None));
}
/// <summary>
/// Adds a parameter.
/// </summary>
/// <param name="commandBuilder">The command builder.</param>
/// <param name="invariantName">
/// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a
/// placeholder for a parameter and not the actual value. This is because the same command can be
/// reused multiple times with different parameter values.
/// </param>
/// <param name="name">
/// The name to be used for the parameter when the command is executed against the database.
/// </param>
/// <returns>The same builder instance so that multiple calls can be chained.</returns>
public static IRelationalCommandBuilder AddParameter(
this IRelationalCommandBuilder commandBuilder,
string invariantName,
string name)
=> commandBuilder.AddParameter(
new DynamicRelationalParameter(
invariantName,
name,
commandBuilder.TypeMappingSource));
public static IRelationalCommandBuilder AddPropertyParameter(
this IRelationalCommandBuilder commandBuilder,
string invariantName,
string name,
IProperty property)
=> commandBuilder.AddParameter(
new TypeMappedPropertyRelationalParameter(
invariantName,
name,
property.GetRelationalTypeMapping(),
property));
/// <summary>
/// Adds a parameter.
/// </summary>
/// <param name="commandBuilder"> The command builder. </param>
/// <param name="invariantName">
/// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a
/// placeholder for a parameter and not the actual value. This is because the same command can be
/// reused multiple times with different parameter values.
/// </param>
/// <param name="dbParameter"> The DbParameter being added. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static IRelationalCommandBuilder AddRawParameter(
this IRelationalCommandBuilder commandBuilder,
string invariantName,
DbParameter dbParameter)
{
Check.NotNull(commandBuilder, nameof(commandBuilder));
Check.NotEmpty(invariantName, nameof(invariantName));
Check.NotNull(dbParameter, nameof(dbParameter));
return(commandBuilder.AddParameter(
new RawRelationalParameter(invariantName, dbParameter)));
}
/// <summary>
/// Adds a parameter.
/// </summary>
/// <param name="commandBuilder">The command builder.</param>
/// <param name="invariantName">
/// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a
/// placeholder for a parameter and not the actual value. This is because the same command can be
/// reused multiple times with different parameter values.
/// </param>
/// <param name="name">
/// The name to be used for the parameter when the command is executed against the database.
/// </param>
/// <param name="relationalTypeMapping">The relational type mapping for this parameter.</param>
/// <param name="nullable">A value indicating whether the parameter could contain a null value.</param>
/// <returns>The same builder instance so that multiple calls can be chained.</returns>
public static IRelationalCommandBuilder AddParameter(
this IRelationalCommandBuilder commandBuilder,
string invariantName,
string name,
RelationalTypeMapping relationalTypeMapping,
bool?nullable)
=> commandBuilder.AddParameter(
new TypeMappedRelationalParameter(
invariantName,
name,
relationalTypeMapping,
nullable));
public static IRelationalCommandBuilder AddParameter(
[NotNull] this IRelationalCommandBuilder commandBuilder,
[NotNull] string name,
[CanBeNull] object value)
{
Check.NotNull(commandBuilder, nameof(commandBuilder));
Check.NotEmpty(name, nameof(name));
return(commandBuilder.AddParameter(
name,
value,
t => t.GetMappingForValue(value),
value?.GetType().IsNullableType()));
}
/// <summary>
/// Adds a parameter that is ultimately represented as multiple <see cref="DbParameter" />s in the
/// final command.
/// </summary>
/// <param name="commandBuilder">The command builder.</param>
/// <param name="invariantName">
/// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a
/// placeholder for a parameter and not the actual value. This is because the same command can be
/// reused multiple times with different parameter values.
/// </param>
/// <param name="subParameters">The parameters to include in the composite.</param>
/// <returns>The same builder instance so that multiple calls can be chained.</returns>
public static IRelationalCommandBuilder AddCompositeParameter(
this IRelationalCommandBuilder commandBuilder,
string invariantName,
IReadOnlyList <IRelationalParameter> subParameters)
{
if (subParameters.Count > 0)
{
commandBuilder.AddParameter(
new CompositeRelationalParameter(
invariantName,
subParameters));
}
return(commandBuilder);
}
/// <summary>
/// Adds a parameter.
/// </summary>
/// <param name="commandBuilder"> The command builder. </param>
/// <param name="invariantName">
/// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a
/// placeholder for a parameter and not the actual value. This is because the same command can be
/// reused multiple times with different parameter values.
/// </param>
/// <param name="name">
/// The name to be used for the parameter when the command is executed against the database.
/// </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static IRelationalCommandBuilder AddParameter(
this IRelationalCommandBuilder commandBuilder,
string invariantName,
string name)
{
Check.NotNull(commandBuilder, nameof(commandBuilder));
Check.NotEmpty(invariantName, nameof(invariantName));
Check.NotEmpty(name, nameof(name));
return(commandBuilder.AddParameter(
new DynamicRelationalParameter(
Check.NotEmpty(invariantName, nameof(invariantName)),
Check.NotEmpty(name, nameof(name)),
commandBuilder.TypeMappingSource)));
}
private static void AddParameter(
[NotNull] this IRelationalCommandBuilder commandBuilder,
[NotNull] string name,
[CanBeNull] object value,
[NotNull] Func <IRelationalTypeMapper, RelationalTypeMapping> mapType,
bool?nullable,
[CanBeNull] string invariantName)
{
Check.NotEmpty(name, nameof(name));
Check.NotNull(mapType, nameof(mapType));
commandBuilder.AddParameter(
commandBuilder.CreateParameter(
name, value, mapType, nullable, invariantName));
}
public static IRelationalCommandBuilder AddParameter(
[NotNull] this IRelationalCommandBuilder commandBuilder,
[NotNull] string name,
[CanBeNull] object value,
[NotNull] IProperty property)
{
Check.NotNull(commandBuilder, nameof(commandBuilder));
Check.NotEmpty(name, nameof(name));
Check.NotNull(property, nameof(property));
return(commandBuilder.AddParameter(
name,
value,
t => t.GetMapping(property),
property.IsNullable));
}
/// <summary>
/// Adds a parameter.
/// </summary>
/// <param name="commandBuilder"> The command builder. </param>
/// <param name="invariantName">
/// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a
/// placeholder for a parameter and not the actual value. This is because the same command can be
/// reused multiple times with different parameter values.
/// </param>
/// <param name="name">
/// The name to be used for the parameter when the command is executed against the database.
/// </param>
/// <param name="property"> The property that the type for this parameter will come from. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static IRelationalCommandBuilder AddParameter(
[NotNull] this IRelationalCommandBuilder commandBuilder,
[NotNull] string invariantName,
[NotNull] string name,
[NotNull] IProperty property)
{
Check.NotNull(commandBuilder, nameof(commandBuilder));
Check.NotEmpty(invariantName, nameof(invariantName));
Check.NotEmpty(name, nameof(name));
Check.NotNull(property, nameof(property));
return(commandBuilder.AddParameter(
new TypeMappedRelationalParameter(
invariantName,
name,
property.FindRelationalMapping(),
property.IsNullable)));
}
public static IRelationalCommandBuilder AddPropertyParameter(
this IRelationalCommandBuilder commandBuilder,
string invariantName,
string name,
IProperty property)
{
Check.NotNull(commandBuilder, nameof(commandBuilder));
Check.NotEmpty(invariantName, nameof(invariantName));
Check.NotEmpty(name, nameof(name));
Check.NotNull(property, nameof(property));
return(commandBuilder.AddParameter(
new TypeMappedPropertyRelationalParameter(
invariantName,
name,
property.GetRelationalTypeMapping(),
property)));
}
/// <summary>
/// Adds a parameter that is ultimately represented as multiple <see cref="DbParameter" />s in the
/// final command.
/// </summary>
/// <param name="commandBuilder"> The command builder. </param>
/// <param name="invariantName">
/// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a
/// placeholder for a parameter and not the actual value. This is because the same command can be
/// reused multiple times with different parameter values.
/// </param>
/// <param name="subParameters"> The parameters to include in the composite. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static IRelationalCommandBuilder AddCompositeParameter(
this IRelationalCommandBuilder commandBuilder,
string invariantName,
IReadOnlyList <IRelationalParameter> subParameters)
{
Check.NotNull(commandBuilder, nameof(commandBuilder));
Check.NotEmpty(invariantName, nameof(invariantName));
Check.NotNull(subParameters, nameof(subParameters));
if (subParameters.Count > 0)
{
commandBuilder.AddParameter(
new CompositeRelationalParameter(
invariantName,
subParameters));
}
return(commandBuilder);
}
/// <summary>
/// Adds a parameter.
/// </summary>
/// <param name="commandBuilder"> The command builder. </param>
/// <param name="invariantName">
/// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a
/// placeholder for a parameter and not the actual value. This is because the same command can be
/// reused multiple times with different parameter values.
/// </param>
/// <param name="name">
/// The name to be used for the parameter when the command is executed against the database.
/// </param>
/// <param name="relationalTypeMapping"> The relational type mapping for this parameter. </param>
/// <param name="nullable"> A value indicating whether the parameter could contain a null value. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static IRelationalCommandBuilder AddParameter(
this IRelationalCommandBuilder commandBuilder,
string invariantName,
string name,
RelationalTypeMapping relationalTypeMapping,
bool?nullable)
{
Check.NotNull(commandBuilder, nameof(commandBuilder));
Check.NotEmpty(invariantName, nameof(invariantName));
Check.NotEmpty(name, nameof(name));
Check.NotNull(relationalTypeMapping, nameof(relationalTypeMapping));
return(commandBuilder.AddParameter(
new TypeMappedRelationalParameter(
invariantName,
name,
relationalTypeMapping,
nullable)));
}
protected override Expression VisitSqlParameter(SqlParameterExpression sqlParameterExpression)
{
var parameterNameInCommand = _sqlGenerationHelper.GenerateParameterName(sqlParameterExpression.Name);
if (_relationalCommandBuilder.Parameters
.All(p => p.InvariantName != sqlParameterExpression.Name))
{
_relationalCommandBuilder.AddParameter(
sqlParameterExpression.Name,
parameterNameInCommand,
sqlParameterExpression.TypeMapping,
sqlParameterExpression.Type.IsNullableType());
}
_relationalCommandBuilder
.Append(_sqlGenerationHelper.GenerateParameterNamePlaceholder(sqlParameterExpression.Name));
return(sqlParameterExpression);
}
protected virtual Expression VisitAsOfTable(AsOfTableExpression tableExpression)
{
Sql.Append(_sqlGenerationHelper.DelimitIdentifier(tableExpression.Name, tableExpression.Schema));
if (tableExpression.DateParameter != null)
{
var name = "__ef_temporal" + tableExpression.DateParameter.Name;
Sql.Append($" FOR SYSTEM_TIME AS OF @{name}"); //2020-02-28T11:00:00
if (!_commandbuilder.Parameters.Any(x => x.InvariantName == tableExpression.DateParameter.Name))
{
_commandbuilder.AddParameter(tableExpression.DateParameter.Name, name);
}
}
Sql
.Append(AliasSeparator)
.Append(_sqlGenerationHelper.DelimitIdentifier(tableExpression.Alias));
return(tableExpression);
}
private IRelationalCommand CreateCommand(Object dataContext, String sql, IReadOnlyList <KeyValuePair <String, Object> > parameters, out Dictionary <String, Object> parameterValues)
{
var dbContext = (DbContext)dataContext;
var commandBuilderFactory = dbContext.GetService <IRelationalCommandBuilderFactory>();
IRelationalCommandBuilder commandBuilder = commandBuilderFactory.Create();
commandBuilder.Append(sql);
var parameterNameGenerator = dbContext.GetService <IParameterNameGeneratorFactory>().Create();
var sqlHelper = dbContext.GetService <ISqlGenerationHelper>();
parameterValues = new Dictionary <String, Object>(parameters.Count);
for (int i = 0; i < parameters.Count; i++)
{
String invariantName = parameterNameGenerator.GenerateNext();
String name = sqlHelper.GenerateParameterName(invariantName);
commandBuilder.AddParameter(invariantName, name);
parameterValues.Add(invariantName, GetParameterCore(parameters[i], name, i));
}
return(commandBuilder.Build());
}
/// <summary>
/// Adds a parameter.
/// </summary>
/// <param name="commandBuilder">The command builder.</param>
/// <param name="invariantName">
/// The key that identifies this parameter. Note that <see cref="IRelationalParameter" /> just represents a
/// placeholder for a parameter and not the actual value. This is because the same command can be
/// reused multiple times with different parameter values.
/// </param>
/// <param name="dbParameter">The DbParameter being added.</param>
/// <returns>The same builder instance so that multiple calls can be chained.</returns>
public static IRelationalCommandBuilder AddRawParameter(
this IRelationalCommandBuilder commandBuilder,
string invariantName,
DbParameter dbParameter)
=> commandBuilder.AddParameter(
new RawRelationalParameter(invariantName, dbParameter));