/// <summary> /// Query ALL /// 查询全部。 /// </summary> /// <typeparam name="TEntity">类型参数</typeparam> /// <param name="connection">DbConnection</param> /// <returns>TEntity 集合</returns> public static IEnumerable <TEntity> QueryALL <TEntity>(this IDbConnection connection) where TEntity : class { try { return(DommelMapper.GetAll <TEntity>(connection)); } catch (Exception ex) { throw new Exception(ex.Message); } }
/// <summary> /// Configures the specified configuration for Dapper.FluentMap.Dommel. /// </summary> /// <param name="config">The Dapper.FluentMap configuration.</param> /// <returns>The Dapper.FluentMap configuration.</returns> public static FluentMapConfiguration ForDommel(this FluentMapConfiguration config) { DommelMapper.SetColumnNameResolver(new DommelColumnNameResolver()); DommelMapper.SetKeyPropertyResolver(new DommelKeyPropertyResolver()); DommelMapper.SetTableNameResolver(new DommelTableNameResolver()); DommelMapper.SetPropertyResolver(new DommelPropertyResolver()); return(config); }
/// <summary> /// Delete /// 根据条件删除。 /// </summary> /// <typeparam name="TEntity">类型参数</typeparam> /// <param name="connection">DbConnection</param> /// <param name="predicate">表达式目录树</param> /// <param name="transaction">事务</param> /// <returns>bool</returns> public static bool Delete <TEntity>(this IDbConnection connection, Expression <Func <TEntity, bool> > predicate, IDbTransaction transaction = null) { try { return(DommelMapper.DeleteMultiple <TEntity>(connection, predicate, transaction)); } catch (Exception ex) { throw new Exception(ex.Message); } }
/// <summary> /// Query FirstOrDefault /// 匹配的第一个实体,如果没有匹配的实体,则选择默认值。 /// </summary> /// <typeparam name="TEntity">类型参数</typeparam> /// <param name="connection">DbConnection</param> /// <param name="predicate">条件表达式目录树</param> /// <returns>TEntity 集合</returns> public static TEntity FirstOrDefault <TEntity>(this IDbConnection connection, Expression <Func <TEntity, bool> > predicate) { try { return(DommelMapper.FirstOrDefault(connection, predicate)); } catch (Exception ex) { throw new Exception(ex.Message); } }
public Repository() { DommelMapper.SetTableNameResolver(new DefaultTableNameResolver()); DommelMapper.SetKeyPropertyResolver(new DefaultKeyPropertyResolver()); DommelMapper.SetColumnNameResolver(new DefaultColumnNameResolver()); DommelMapper.SetPropertyResolver(new DefaultPropertyResolver()); DommelMapper.SetForeignKeyPropertyResolver(new DefaultForeignKeyPropertyResolver()); }
/// <summary> /// Delete ALL /// 删除全部。 /// </summary> /// <typeparam name="TEntity">类型参数</typeparam> /// <param name="connection">DbConnection</param> /// <param name="transaction">事务</param> /// <returns>bool</returns> public static bool DeleteAll <TEntity>(this IDbConnection connection, IDbTransaction transaction = null) { try { return(DommelMapper.DeleteAll <TEntity>(connection, transaction)); } catch (Exception ex) { throw new Exception(ex.Message); } }
/// <summary> /// Update /// 根据传入实体修改。 /// </summary> /// <typeparam name="TEntity">类型参数</typeparam> /// <param name="connection">DbConnection</param> /// <param name="entity">实体数据信息</param> /// <param name="transaction">事务</param> /// <returns>bool</returns> public static bool Update <TEntity>(this IDbConnection connection, TEntity entity, IDbTransaction transaction = null) { try { return(DommelMapper.Update <TEntity>(connection, entity, transaction)); } catch (Exception ex) { throw new Exception(ex.Message); } }
/// <summary> /// Query /// 根据主键“ID” /// </summary> /// <typeparam name="TEntity">类型参数</typeparam> /// <param name="connection">DbConnection</param> /// <param name="id">主键ID值</param> /// <returns>TEntity</returns> public static TEntity Query <TEntity>(this IDbConnection connection, object id) where TEntity : class { try { return(DommelMapper.Get <TEntity>(connection, id)); } catch (Exception ex) { throw new Exception(ex.Message); } }
public RuntimeInitializer DefaultMapper(Type type) { DapperExtensions.DapperExtensions.DefaultMapper = type; DommelMapper.SetTableNameResolver(new TableNameResolver()); DommelMapper.SetKeyPropertyResolver(new KeyPropertyResolver()); DommelMapper.SetColumnNameResolver(new ColumnNameResolver()); return(this); }
private void InitializeEntityMappings() { FluentMapper.Initialize(config => { config.ForDommel(); DommelMapper.SetKeyPropertyResolver(new PrimaryKeyResolver()); DommelMapper.SetTableNameResolver(new TableNameResolver()); }); }
/// <summary> /// Insert SQL /// return bool /// </summary> /// <typeparam name="TEntity">类型参数</typeparam> /// <param name="connection">DbConnection</param> /// <param name="entity">entity</param> /// <param name="transaction">DbTransaction</param> /// <returns>object</returns> public static bool Insert <TEntity>(this IDbConnection connection, TEntity entity, IDbTransaction transaction = null) where TEntity : class { try { DommelMapper.Insert <TEntity>(connection, entity, transaction); return(true); } catch (Exception ex) { throw new Exception(ex.Message); } }
public ParameterPrefixTest() { mock.As <IDbConnection>().SetupDapper(x => x.QueryFirstOrDefault <FooParameterPrefix>(It.IsAny <string>(), It.IsAny <object>(), null, null, null)) .Returns(new FooParameterPrefix()); var connectionType = mock.Object.GetType(); // Change the default Sql Connection DommelMapper.AddSqlBuilder(connectionType, new ExampleBuilderBuilder()); }
/// <summary> /// Configures Dommel JSON support using the specified <see cref="DommelJsonOptions"/>. /// </summary> /// <param name="options"></param> public static void AddJson(DommelJsonOptions options) { if (options == null) { throw new ArgumentNullException(nameof(options)); } if (options.EntityAssemblies == null || options.EntityAssemblies.Length == 0) { throw new ArgumentException("No entity assemblies specified.", nameof(options)); } // Add SQL builders with JSON value support DommelMapper.AddSqlBuilder("sqlconnection", new SqlServerSqlBuilder()); DommelMapper.AddSqlBuilder("sqlceconnection", new SqlServerCeSqlBuilder()); DommelMapper.AddSqlBuilder("sqliteconnection", new SqliteSqlBuilder()); DommelMapper.AddSqlBuilder("npgsqlconnection", new PostgresSqlBuiler()); DommelMapper.AddSqlBuilder("mysqlconnection", new MySqlSqlBuilder()); // Add a custom SqlExpression<T> factory with JSON support DommelMapper.SqlExpressionFactory = (type, sqlBuilder) => { if (!(sqlBuilder is IJsonSqlBuilder)) { throw new InvalidOperationException($"The specified SQL builder type should be assignable from {nameof(IJsonSqlBuilder)}."); } var sqlExpression = typeof(JsonSqlExpression <>).MakeGenericType(type); return(Activator.CreateInstance(sqlExpression, sqlBuilder)); }; // Add a Dapper type mapper with JSON support for // properties annotated with the [JsonData] attribute. var jsonTypeHander = options.JsonTypeHandler?.Invoke() ?? new JsonObjectTypeHandler(); var jsonTypes = new List <Type>(); foreach (var assembly in options.EntityAssemblies) { foreach (var type in assembly.ExportedTypes) { foreach (var property in type.GetRuntimeProperties()) { var jsonAttr = property.GetCustomAttribute <JsonDataAttribute>(); if (jsonAttr != null) { SqlMapper.AddTypeHandler(property.PropertyType, jsonTypeHander); jsonTypes.Add(property.PropertyType); } } } } // Set a property resolver which considers the types discovered above // as primitive types so they will be used in insert and update queries. DommelMapper.SetPropertyResolver(new JsonPropertyResolver(jsonTypes)); }
static DataSource() { SqlMapper.AddTypeHandler <JObject>(new JObjectHandler()); FluentMapper.Initialize(config => { config.AddMap(new TokenDbMap()); config.ApplyToDommel(); }); DommelMapper.SetPropertyResolver(new DommelPropertyResolverForCustomTypes()); }
public long GetList_Count(Expression <Func <T, bool> > filter = null) { _tableName = typeof(T).Name; using (var connection = CreateConnection()) { DommelMapper.SetTableNameResolver(new CustomTableNameResolver()); return(filter == null ? connection.QueryFirstOrDefault <long>($"SELECT COUNT(1) FROM {_tableName}") : connection.Count <T>(filter)); } }
public IEnumerable <T> GetList(Expression <Func <T, bool> > filter = null) { _tableName = typeof(T).Name; using (var connection = CreateConnection()) { DommelMapper.SetTableNameResolver(new CustomTableNameResolver()); return(filter == null ? connection.Query <T>($"SELECT * FROM {_tableName}") : connection.Select(filter)); } }
static GuildConfigRepository() { FluentMapper.Initialize(config => { config .AddConvention <LowerCaseConvention>() .ForEntity <GuildConfigEntity>(); config.ForDommel(); DommelMapper.SetColumnNameResolver(new LowerCaseConvention()); DommelMapper.AddSqlBuilder(typeof(NpgsqlConnection), new PostgresSqlBuilder()); }); }
public void GetBuilderLogsChosenBuilder() { // Arrange var logs = new List <string>(); var mock = new Mock <IDbConnection>(); DommelMapper.LogReceived = s => logs.Add(s); // Act DommelMapper.GetSqlBuilder(mock.Object); // Assert Assert.True(logs.Count > 0); Assert.Contains("Selected SQL Builder 'SqlServerSqlBuilder' for connection type 'IDbConnectionProxy'", logs); }
protected virtual async Task DropTables() { using var con = GetConnection(DefaultDatabaseName); var sqlBuilder = DommelMapper.GetSqlBuilder(con); string Quote(string s) => sqlBuilder.QuoteIdentifier(s); await con.ExecuteAsync($@" DROP TABLE {Quote("Categories")}; DROP TABLE {Quote("Products")}; DROP TABLE {Quote("ProductsCategories")}; DROP TABLE {Quote("ProductOptions")}; DROP TABLE {Quote("Orders")}; DROP TABLE {Quote("OrderLines")}; DROP TABLE {Quote("Foos")}; DROP TABLE {Quote("Bars")}; DROP TABLE {Quote("Bazs")};"); }
/// <summary> /// Query /// 根据条件查询。 /// </summary> /// <typeparam name="TEntity">类型参数</typeparam> /// <param name="connection">DbConnection</param> /// <param name="predicate">条件表达式目录树</param> /// <returns>TEntity 集合</returns> public static IEnumerable <TEntity> Query <TEntity>(this IDbConnection connection, Expression <Func <TEntity, bool> > predicate) { try { if (SqlCheck.Check <TEntity>(predicate)) { DynamicParameters parameters; var querySQL = BuildSelectSql(predicate, out parameters); return(SqlMapper.Query <TEntity>(connection, querySQL, parameters)); } else { return(DommelMapper.Select <TEntity>(connection, predicate)); } } catch (Exception ex) { throw new Exception(ex.Message); } }
static YuGiOhRepository() { FluentMapper.Initialize(config => { config .AddConvention <LowerCaseConvention>() .ForEntity <CardEntity>() .ForEntity <BoosterPackEntity>(); config.AddMap(new CardEntityMapper()); config.AddMap(new BoosterPackEntityMapper()); config.ForDommel(); var resolver = new LowerCaseConvention(); DommelMapper.SetColumnNameResolver(resolver); DommelMapper.AddSqlBuilder(typeof(NpgsqlConnection), new PostgresSqlBuilder()); }); }
private void CreateMapper() { FluentMapper.Initialize(configuration => { configuration.ForDommel(); DommelMapper.SetPropertyResolver(new CustomPropertyResolver()); }); foreach (KeyValuePair <Type, IEntityMap> key in FluentMapper.EntityMaps) { ICustomDapperMapper customMapper = key.Value as ICustomDapperMapper; if (customMapper != null) { customMapper.Map(); } } SqlMapper.AddTypeHandler(new NullableLongHandler()); }
public async Task InsertGuidPrimaryKey() { if (CI.IsTravis) { // Don't run SQL Server test on Linux return; } using (var con = new SqlServerDatabaseDriver().GetConnection()) { await con.ExecuteAsync("CREATE TABLE dbo.Quxs (Id UNIQUEIDENTIFIER NOT NULL DEFAULT NEWID(), Name VARCHAR(255));"); try { object identity; try { DommelMapper.AddSqlBuilder(typeof(SqlConnection), new GuidSqlServerSqlBuilder()); identity = await con.InsertAsync(new Qux { Name = "blah" }); } finally { DommelMapper.AddSqlBuilder(typeof(SqlConnection), new DommelMapper.SqlServerSqlBuilder()); } Assert.NotNull(identity); var id = Assert.IsType <Guid>(identity); var baz = await con.GetAsync <Qux>(id); Assert.NotNull(baz); Assert.Equal("blah", baz.Name); Assert.Equal(id, baz.Id); } finally { await con.ExecuteAsync("DROP TABLE dbo.Quxs"); } } }
/// <summary> /// 自定义相关解析注入 /// </summary> static DapperExtensions() { DommelMapper.SetTableNameResolver(new CustomTableNameResolver()); //TableName DommelMapper.SetKeyPropertyResolver(new CustomKeyPropertyResolver()); //Key }
public override TEntity Get(TPrimaryKey id) => DommelMapper.Get <TEntity>(Connection, id, Transaction) ?? throw new Exception("EntityNotFoundException");
public Startup(IConfiguration configuration) { DommelMapper.SetTableNameResolver(new DommelTableNameResolver()); Configuration = configuration; StaticConfig = configuration; }
public static void Configure() { DommelMapper.SetTableNameResolver(new UnderscoreTableNameResolver()); DommelMapper.SetColumnNameResolver(new UnderscoreColumnNameResolver()); DefaultTypeMap.MatchNamesWithUnderscores = true; }
public Startup(IConfiguration configuration) { this.Configuration = configuration; DommelMapper.SetTableNameResolver(new CustomTableNameResolver()); }