public void Can_add_composite_parameter()
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(
typeMapper,
new ExceptionDetector()));
parameterBuilder.AddCompositeParameter(
"CompositeInvariant",
new List <IRelationalParameter>
{
new TypeMappedRelationalParameter(
"FirstInvariant",
"FirstName",
new IntTypeMapping("int", DbType.Int32),
nullable: false),
new TypeMappedRelationalParameter(
"SecondInvariant",
"SecondName",
new StringTypeMapping("nvarchar(max)", DbType.String),
nullable: true)
});
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as CompositeRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("CompositeInvariant", parameter.InvariantName);
Assert.Equal(2, parameter.RelationalParameters.Count);
}
public RelationalCommandListBuilder([NotNull] IRelationalCommandBuilderFactory commandBuilderFactory)
{
Check.NotNull(commandBuilderFactory, nameof(commandBuilderFactory));
_commandBuilderFactory = commandBuilderFactory;
_commandBuilder = commandBuilderFactory.Create();
}
public void Can_add_type_mapped_parameter_by_type(bool nullable)
{
var typeMapper = (IRelationalTypeMappingSource) new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var typeMapping = typeMapper.FindMapping(nullable ? typeof(int?) : typeof(int));
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(
typeMapper,
new ExceptionDetector()));
parameterBuilder.AddParameter(
"InvariantName",
"Name",
typeMapping,
nullable);
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as TypeMappedRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("InvariantName", parameter.InvariantName);
Assert.Equal("Name", parameter.Name);
Assert.Equal(typeMapping, parameter.RelationalTypeMapping);
Assert.Equal(nullable, parameter.IsNullable);
}
public void Can_add_type_mapped_parameter_by_property(bool nullable)
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var modelBuilder = RelationalTestHelpers.Instance.CreateConventionBuilder();
modelBuilder.Entity("MyType").Property <string>("MyProp").IsRequired(!nullable);
var model = modelBuilder.FinalizeModel(designTime: false, skipValidation: true);
var property = model.GetEntityTypes().Single().FindProperty("MyProp");
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(typeMapper, new ExceptionDetector()));
parameterBuilder.AddParameter(
"InvariantName",
"Name",
property.GetRelationalTypeMapping(),
property.IsNullable);
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as TypeMappedRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("InvariantName", parameter.InvariantName);
Assert.Equal("Name", parameter.Name);
Assert.Equal(property.GetTypeMapping(), parameter.RelationalTypeMapping);
Assert.Equal(nullable, parameter.IsNullable);
}
public virtual RelationalCommandListBuilder EndCommand()
{
if (_commandBuilder.Length != 0)
{
_commands.Add(_commandBuilder.BuildRelationalCommand());
_commandBuilder = _commandBuilderFactory.Create();
}
return(this);
}
private static RelationalCommandBuilder CreateCommandBuilder()
{
var dependencies = new RelationalCommandBuilderDependencies(
new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>()));
var commandBuilder = new RelationalCommandBuilder(dependencies);
return(commandBuilder);
}
public virtual RelationalCommand GenerateSql(IDictionary <string, object> parameterValues)
{
Check.NotNull(parameterValues, nameof(parameterValues));
_sql = _commandBuilderFactory.Create();
_parameterNameGenerator = _parameterNameGeneratorFactory.Create();
_parameterValues = parameterValues;
Visit(SelectExpression);
return(_sql.BuildRelationalCommand());
}
public void Does_not_add_empty_composite_parameter()
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(
typeMapper));
parameterBuilder.AddCompositeParameter(
"CompositeInvariant",
new List <IRelationalParameter>());
Assert.Equal(0, parameterBuilder.Parameters.Count);
}
protected virtual void PopulateParameters(
[NotNull] RelationalCommandBuilder commandBuilder,
[NotNull] ColumnModification columnModification)
{
if (columnModification.ParameterName != null)
{
commandBuilder.AddParameter(
columnModification.ParameterName,
columnModification.Value,
columnModification.Property);
}
if (columnModification.OriginalParameterName != null)
{
commandBuilder.AddParameter(
columnModification.OriginalParameterName,
columnModification.OriginalValue,
columnModification.Property);
}
}
public void Can_add_dynamic_parameter()
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(
typeMapper));
parameterBuilder.AddParameter(
"InvariantName",
"Name");
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as DynamicRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("InvariantName", parameter.InvariantName);
Assert.Equal("Name", parameter.Name);
}
public void PopulateParametersBase(RelationalCommandBuilder commandBuilder, ColumnModification columnModification)
{
base.PopulateParameters(commandBuilder, columnModification);
}
protected override void PopulateParameters(RelationalCommandBuilder commandBuilder, ColumnModification columnModification)
{
PopulateParameterCalls++;
}
