public SqlCommandProcessor(SqlMapperEngine engine)
{
this.engine = engine;
if (engine.Driver.SupportDataManipulationLanguage)
{
driver = engine.Driver;
dialect = engine.Dialect;
}
else
{
driver = engine.AlternateDriver;
dialect = engine.AlternateDialect;
}
Connection = driver.CreateConnection();
}
public DialectProxy(IDialect dialect)
{
Dialect = dialect;
}
private static string GetTableNameFromAttribute(IDialect dialect, TableAttribute tableAttribute)
{
return(string.IsNullOrEmpty(tableAttribute.Schema)
? dialect.MakeTableName(tableAttribute.Name)
: dialect.MakeTableName(tableAttribute.Schema, tableAttribute.Name));
}
public OnDeleteNoActionConstraint(IDialect dialect)
{
_dialect = dialect;
}
/// <summary>
/// 初始化MySql 表连接子句
/// </summary>
/// <param name="sqlBuilder">Sql生成器</param>
/// <param name="dialect">方言</param>
/// <param name="resolver">实体解析器</param>
/// <param name="register">实体注册器</param>
public MySqlJoinClause(ISqlBuilder sqlBuilder, IDialect dialect, IEntityResolver resolver, IEntityAliasRegister register)
: base(sqlBuilder, dialect, resolver, register)
{
}
/// <summary>
/// 初始化一个<see cref="SqlContext"/>类型的实例
/// </summary>
/// <param name="entityAliasRegister">实体别名注册器</param>
/// <param name="whereClause">Where子句</param>
/// <param name="matedata">实体元数据解析器</param>
/// <param name="dialect">Sql方言</param>
public SqlContext(IEntityAliasRegister entityAliasRegister, IWhereClause whereClause, IEntityMatedata matedata, IDialect dialect)
{
EntityAliasRegister = entityAliasRegister ?? new EntityAliasRegister();
WhereClause = whereClause ?? throw new ArgumentNullException(nameof(whereClause));
Matedata = matedata;
Dialect = dialect;
}
public OracleHelper()
{
_Dialect = new OracleDialect();
}
public MySqlHelper()
{
_Dialect = new MySqlDialect();
}
public void Rollsback_changes_when_exception_is_thrown_in_transaction(IDialect dialect)
{
using (var database = BlankDatabaseFactory.MakeDatabase(dialect))
{
// Act
Action act = () =>
{
using (var unitOfWork = database.StartUnitOfWork())
{
var command = database.CommandFactory().MakeInsertCommand(new Dog {
Name = "Foo", Age = 4
});
unitOfWork.Execute(command.CommandText, command.Parameters);
throw new Exception();
}
};
// Assert
act.Should().Throw <Exception>();
database.Count <Dog>().Should().Be(0);
}
}
public void Rollsback_changes_when_transaction_is_disposed_without_saving(IDialect dialect)
{
using (var database = BlankDatabaseFactory.MakeDatabase(dialect))
{
// Act
using (var unitOfWork = database.StartUnitOfWork())
{
var command = database.CommandFactory().MakeInsertCommand(new Dog {
Name = "Foo", Age = 4
});
unitOfWork.Execute(command.CommandText, command.Parameters);
}
// Assert
database.Count <Dog>().Should().Be(0);
}
}
public MySqlStringContainsInterceptor(IDialect dialect) : base(dialect)
{
}
/// <summary>
/// 测试初始化
/// </summary>
public PredicateExpressionResolverTest()
{
_dialect = new SqlServerDialect();
_parameterManager = new ParameterManager(_dialect);
_resolver = new PredicateExpressionResolver(_dialect, new EntityResolver(), new EntityAliasRegister(), _parameterManager);
}
/// <summary>
/// 初始化一个<see cref="PredicateExpressionResolver"/>类型的实例
/// </summary>
/// <param name="dialect">Sql方言</param>
/// <param name="resolver">实体解析器</param>
/// <param name="register">实体别名注册器</param>
/// <param name="parameterManager">参数管理器</param>
public PredicateExpressionResolver(IDialect dialect, IEntityResolver resolver, IEntityAliasRegister register,
IParameterManager parameterManager) =>
public async Task Finds_entities_with_all_possible_types(IDialect dialect)
{
using (var database = BlankDatabaseFactory.MakeDatabase(dialect))
{
// Arrange
var id = database.Insert <int>(
new PropertyAllPossibleTypes
{
Int16Property = -16,
NullableInt16Property = -16,
Int32Property = -32,
NullableInt32Property = -32,
Int64Property = -64,
NullableInt64Property = -64,
SingleProperty = 1,
NullableSingleProperty = 1,
DoubleProperty = 2,
NullableDoubleProperty = 2,
DecimalProperty = 10,
NullableDecimalProperty = 10,
BoolProperty = true,
NullableBoolProperty = true,
StringProperty = "Foo",
CharProperty = 'F',
NullableCharProperty = 'N',
GuidProperty = new Guid("da8326a1-c703-4a79-9fb2-2909b0f40367"),
NullableGuidProperty = new Guid("706e6bcf-4a6d-4d19-91e9-935852140c4d"),
DateTimeProperty = new DateTime(2016, 12, 31),
NullableDateTimeProperty = new DateTime(2016, 12, 31),
DateTimeOffsetProperty = new DateTimeOffset(new DateTime(2016, 12, 31), new TimeSpan(0, 1, 0, 0)),
NullableDateTimeOffsetProperty = new DateTimeOffset(new DateTime(2016, 12, 31), new TimeSpan(0, 1, 0, 0)),
ByteArrayProperty = new byte[] { 1, 2, 3 }
});
// Act
var entity = await database.FindAsync <PropertyAllPossibleTypes>(id);
// Assert
entity.Int16Property.Should().Be(-16);
entity.NullableInt16Property.Should().Be(-16);
entity.Int32Property.Should().Be(-32);
entity.NullableInt32Property.Should().Be(-32);
entity.Int64Property.Should().Be(-64);
entity.NullableInt64Property.Should().Be(-64);
entity.SingleProperty.Should().Be(1);
entity.NullableSingleProperty.Should().Be(1);
entity.DoubleProperty.Should().Be(2);
entity.NullableDoubleProperty.Should().Be(2);
entity.DecimalProperty.Should().Be(10);
entity.NullableDecimalProperty.Should().Be(10);
entity.BoolProperty.Should().Be(true);
entity.NullableBoolProperty.Should().Be(true);
entity.StringProperty.Should().Be("Foo");
entity.CharProperty.Should().Be('F');
entity.NullableCharProperty.Should().Be('N');
entity.GuidProperty.Should().Be(new Guid("da8326a1-c703-4a79-9fb2-2909b0f40367"));
entity.NullableGuidProperty.Should().Be(new Guid("706e6bcf-4a6d-4d19-91e9-935852140c4d"));
entity.DateTimeProperty.Should().Be(new DateTime(2016, 12, 31));
entity.NullableDateTimeProperty.Should().Be(new DateTime(2016, 12, 31));
entity.DateTimeOffsetProperty.Should().Be(new DateTimeOffset(new DateTime(2016, 12, 31), new TimeSpan(0, 1, 0, 0)));
entity.NullableDateTimeOffsetProperty.Should().Be(new DateTimeOffset(new DateTime(2016, 12, 31), new TimeSpan(0, 1, 0, 0)));
entity.ByteArrayProperty.Should().BeEquivalentTo(new byte[] { 1, 2, 3 }, o => o.WithStrictOrdering());
}
}
public DropSchemaRenderer(IDialect dialect)
{
_dialect = dialect;
}
public override void ExportTo(IDialect exporter)
{
//foreignRelationshipMapping.ExportTo(exporter);
}
public AccessHelper()
{
_Dialect = new AccessDialect();
}
/// <summary>
/// 初始化参数管理器
/// </summary>
/// <param name="dialect">Sql方言</param>
/// <param name="data">参数集合</param>
/// <param name="index">参数索引</param>
public ParameterManager(IDialect dialect, IDictionary <string, object> data = null, int?index = null)
{
_dialect = dialect;
_params = data ?? new Dictionary <string, object>();
_paramIndex = index.SafeValue();
}
private AggregateRewriter(IDialect dialect, Expression expr)
{
this.dialect = dialect;
this.map = new Dictionary<AggregateSubqueryExpression, Expression>();
this.lookup = AggregateGatherer.Gather(expr).ToLookup(a => a.GroupByAlias, TableAlias.Comparer);
}
/// <summary>
/// 生成数据库脚本
/// </summary>
/// <param name="dialect">数据库方言</param>
/// <param name="mappings">映射元数据</param>
/// <param name="dbName">数据库名称</param>
/// <returns>返回数据库脚本</returns>
public DatabaseScriptEntry Build(IDialect dialect, Mapping.IEntityMapping[] mappings, string databaseName)
{
Guard.NotNull(dialect, "dialect");
Guard.NotNull(mappings, "mappings");
if (mappings.Length == 0)
{
throw new ArgumentNullException("mappings");
}
this.Dialect = dialect;
var Mappings = mappings;
DatabaseName = databaseName;
Entry = new DatabaseScriptEntry();
BuildDatabaseScript(databaseName);
if (dialect.SupportSchema)
{
Entry.SchemaScripts = BuildSchemaScript(mappings)
.Where(p => p.HasValue())
.ToArray();
}
var sequanceScript = BuildAllSequanceScripts(Mappings)
.Where(p => p.HasValue())
.ToArray();
var pkScript = Mappings
.Where(p => p.PrimaryKeys.Length > 0)
.Select(p => BuildPKScript(p.PrimaryKeys))
.Where(p => p.HasValue())
.ToArray();
var checkScript = Mappings.Where(p => p.Members.Any(m => m.IsCheck))
.SelectMany(p => p.Members.Where(m => m.IsCheck))
.Select(p => BuildCheckConstraintScript(p))
.Where(p => p.HasValue())
.ToArray();
var fkScript = Mappings.Where(p => p.Members.Any(m => m.IsManyToOne))
.SelectMany(p => p.Members.Where(m => m.IsManyToOne))
.Select(p => BuildFKScript(p))
.Where(p => p.HasValue())
.ToArray();
var uniquleScript = Mappings.Where(p => p.Members.Any(m => m.IsUniqule))
.SelectMany(p => p.Members.Where(m => m.IsUniqule))
.Select(p => BuildUniquleConstraintScript(p))
.Where(p => p.HasValue())
.ToArray();
if (Dialect.SupportMultipleCommands)
{
Entry.TableScripts = new string[]
{
Mappings.Select(p => BuildTableScript(p)).ToCSV(";")
};
if (pkScript.Length > 0)
{
Entry.PKConstraintScripts = new string[] { pkScript.ToCSV(";") }
}
;
if (fkScript.Length > 0)
{
Entry.FKConstraintScripts = new string[] { fkScript.ToCSV(";") }
}
;
if (checkScript.Length > 0)
{
Entry.CheckConstraintScript = new string[] { checkScript.ToCSV(";") }
}
;
if (uniquleScript.Length > 0)
{
Entry.UniquleConstraintScripts = new string[] { uniquleScript.ToCSV(";") }
}
;
if (sequanceScript.Length > 0)
{
Entry.SequenceScripts = new string[] { sequanceScript.ToCSV(";") }
}
;
}
else
{
Entry.TableScripts = Mappings.Select(p => BuildTableScript(p)).ToArray();
Entry.PKConstraintScripts = pkScript;
Entry.FKConstraintScripts = fkScript;
Entry.CheckConstraintScript = checkScript;
Entry.UniquleConstraintScripts = uniquleScript;
Entry.SequenceScripts = sequanceScript;
}
return(Entry);
}
public virtual void ExportTo(IDialect exporter)
{
}
public CreateUniqueConstraintRenderer(IDialect dialect)
{
_dialect = dialect;
}
/// <summary>
/// 获取Join语句
/// </summary>
/// <param name="dialect">Sql方言</param>
/// <returns></returns>
public string ToSql(IDialect dialect)
{
var table = Table.ToSql(dialect);
return($"{JoinType} {table}{GetOn(dialect)}");
}
public OracleStringContainsInterceptor(IDialect dialect) : base(dialect)
{
}
public Transactionable(IDbConnectionProvider provider, IDialect dialect, string databaseName) : base(provider, dialect)
{
_databaseName = databaseName;
EnableUseStatement();
}
public PostgresStringContainsInterceptor(IDialect dialect) : base(dialect)
{
}
/// <summary>
/// 初始化一个<see cref="PredicateExpressionResolver"/>类型的实例
/// </summary>
/// <param name="dialect">Sql方言</param>
/// <param name="resolver">实体解析器</param>
/// <param name="register">实体别名注册器</param>
/// <param name="parameterManager">参数管理器</param>
public PredicateExpressionResolver(IDialect dialect, IEntityResolver resolver, IEntityAliasRegister register,
IParameterManager parameterManager)
{
_helper = new Helper(dialect, resolver, register, parameterManager);
}
public DropPrimaryKeyConstraintRenderer(IDialect dialect)
{
_dialect = dialect;
}
public TraceDialect(IDialect dialect)
: base(dialect)
{
}
public ClusteredConstraint(IDialect dialect)
{
_dialect = dialect;
}
/// <summary>
/// 生成数据库脚本
/// </summary>
/// <param name="dialect">数据库方言</param>
/// <param name="mappings">映射元数据</param>
/// <param name="dbName">数据库名称</param>
/// <returns>返回数据库脚本</returns>
public DatabaseScriptEntry Build(IDialect dialect, Mapping.IEntityMapping[] mappings,string databaseName)
{
Guard.NotNull(dialect, "dialect");
Guard.NotNull(mappings, "mappings");
if (mappings.Length == 0)
throw new ArgumentNullException("mappings");
this.Dialect = dialect;
var Mappings = mappings;
DatabaseName = databaseName;
Entry = new DatabaseScriptEntry();
BuildDatabaseScript(databaseName);
if (dialect.SupportSchema)
Entry.SchemaScripts = BuildSchemaScript(mappings)
.Where(p => p.HasValue())
.ToArray();
var sequanceScript = BuildAllSequanceScripts(Mappings)
.Where(p => p.HasValue())
.ToArray();
var pkScript = Mappings
.Where(p => p.PrimaryKeys.Length > 0)
.Select(p => BuildPKScript(p.PrimaryKeys))
.Where(p => p.HasValue())
.ToArray();
var checkScript = Mappings.Where(p => p.Members.Any(m => m.IsCheck))
.SelectMany(p => p.Members.Where(m => m.IsCheck))
.Select(p => BuildCheckConstraintScript(p))
.Where(p => p.HasValue())
.ToArray();
var fkScript = Mappings.Where(p => p.Members.Any(m => m.IsManyToOne))
.SelectMany(p => p.Members.Where(m => m.IsManyToOne))
.Select(p => BuildFKScript(p))
.Where(p => p.HasValue())
.ToArray();
var uniquleScript= Mappings.Where(p => p.Members.Any(m => m.IsUniqule))
.SelectMany(p => p.Members.Where(m => m.IsUniqule))
.Select(p => BuildUniquleConstraintScript(p))
.Where(p => p.HasValue())
.ToArray();
if (Dialect.SupportMultipleCommands)
{
Entry.TableScripts = new string[]
{
Mappings.Select(p=>BuildTableScript(p)).ToCSV(";")
};
if (pkScript.Length > 0)
Entry.PKConstraintScripts = new string[] { pkScript.ToCSV(";") };
if (fkScript.Length > 0)
Entry.FKConstraintScripts = new string[] { fkScript.ToCSV(";") };
if (checkScript.Length > 0)
Entry.CheckConstraintScript = new string[] { checkScript.ToCSV(";") };
if (uniquleScript.Length > 0)
Entry.UniquleConstraintScripts = new string[] { uniquleScript.ToCSV(";") };
if (sequanceScript.Length > 0)
Entry.SequenceScripts = new string[] { sequanceScript.ToCSV(";")};
}
else
{
Entry.TableScripts = Mappings.Select(p => BuildTableScript(p)).ToArray();
Entry.PKConstraintScripts = pkScript;
Entry.FKConstraintScripts = fkScript;
Entry.CheckConstraintScript = checkScript;
Entry.UniquleConstraintScripts = uniquleScript;
Entry.SequenceScripts = sequanceScript;
}
return Entry;
}
/// <summary>
/// 初始化一个<see cref="OracleJoinClause"/>类型的的实例
/// </summary>
/// <param name="sqlBuilder">Sql生成器</param>
/// <param name="dialect">Sql方言</param>
/// <param name="resolver">实体解析器</param>
/// <param name="register">实体注册器</param>
/// <param name="parameterManager">参数管理器</param>
/// <param name="tableDatabase">表数据库</param>
public OracleJoinClause(ISqlBuilder sqlBuilder, IDialect dialect, IEntityResolver resolver,
IEntityAliasRegister register, IParameterManager parameterManager, ITableDatabase tableDatabase) : base(
sqlBuilder, dialect, resolver, register, parameterManager, tableDatabase)
{
}
public override void ExportTo(IDialect exporter)
{
exporter.CreateForeignKey(this, id);
}
public DropColumnRenderer(IDialect dialect)
{
_dialect = dialect;
}
public AccessHelper(string connStr)
: base(connStr)
{
_Dialect = new AccessDialect();
}
private Parameterizer(IDialect dialect)
{
this.dialect = dialect;
}
public MySqlHelper(string connStr)
: base(connStr)
{
_Dialect = new MySqlDialect();
}
public static Expression Parameterize(IDialect dialect, Expression expression)
{
return(new Parameterizer(dialect).Visit(expression));
}
public static Expression Rewrite(IDialect dialect, Expression expr)
{
return new AggregateRewriter(dialect, expr).Visit(expr);
}
/// <summary>
/// 初始化一个<see cref="MySqlFromClause"/>类型的实例
/// </summary>
/// <param name="builder">Sql生成器</param>
/// <param name="dialect">方言</param>
/// <param name="resolver">实体解析器</param>
/// <param name="register">实体别名注册器</param>
/// <param name="tableDatabase">表数据库</param>
/// <param name="table">表</param>
public MySqlFromClause(ISqlBuilder builder, IDialect dialect, IEntityResolver resolver,
IEntityAliasRegister register, ITableDatabase tableDatabase, SqlItem table = null) : base(
builder, dialect, resolver, register, tableDatabase, table)
{
}
public OracleHelper(string connStr)
: base(connStr)
{
_Dialect = new OracleDialect();
}
public AddColumnRenderer(IDialect dialect)
{
_dialect = dialect;
}
public SqlExporter()
{
this.dialect = new MsSqlDialect(this);
}
public CreateForeignKeyConstraintRenderer(IDialect dialect)
{
_dialect = dialect;
}
