private static DataConnection CreateDataConnection(string connectionString, SqlServerVersion sqlServerVersion) { var sqlServerDataProvider = (SqlServerDataProvider)SqlServerTools.GetDataProvider(sqlServerVersion, SqlServerProvider.MicrosoftDataSqlClient); DatabaseContext.CreateMappings(sqlServerDataProvider.MappingSchema); return(new DataConnection(sqlServerDataProvider, new SqlConnection(connectionString))); }
public static void Run(string platform, bool asyncProcessing) { Console.WriteLine($"Testing {platform}..."); var serverName = "."; DataConnection.AddConfiguration( "Test", $"Server={serverName};Database=PerformanceTest;Trusted_Connection=True;Application Name=LinqToDB Test;" + (asyncProcessing ? "Asynchronous Processing=True;" : ""), SqlServerTools.GetDataProvider(SqlServerVersion.v2012)); DataConnection.DefaultConfiguration = "Test"; var basePath = Path.GetDirectoryName(typeof(LinqTestRunner).Assembly.Location); while (!Directory.Exists(Path.Combine(basePath, "Result"))) { basePath = Path.GetDirectoryName(basePath); } var resultPath = Path.Combine(basePath, "Result"); CreateResultDatabase(false, resultPath); CreateTestDatabase(false, serverName); RunTests(platform); }
public void Test1(string context) { var connectionString = ConfigurationManager.ConnectionStrings["Northwind"].ConnectionString; using (var conn = new DataConnection(SqlServerTools.GetDataProvider(), connectionString)) { conn.InitCommand(CommandType.Text, "SELECT 1", null, null); var rd = conn.Command.ExecuteReader(); if (rd.Read()) { var dp = conn.DataProvider; var p = Expression.Parameter(typeof(IDataReader)); var dr = Expression.Convert(p, dp.DataReaderType); var ex = (Expression <Func <IDataReader, int, int> >)dp.GetReaderExpression(conn.MappingSchema, rd, 0, dr, typeof(int)); var func = ex.Compile(); do { var value = func(rd, 0); Assert.AreEqual(1, value); } while (rd.Read()); } else { Assert.Fail(); } } }
/// <summary> /// Creates an <see cref="IDataProvider" /> that uses Microsoft.Data.SqlClient internally. /// </summary> /// <param name="sqlServerVersion">The SQL Server version of the target database (optional). Defaults to <see cref="SqlServerVersion.v2017" />.</param> /// <param name="createMappings"> /// The delegate that manipulates the mapping schema of the data provider (optional). Alternatively, you could use the Linq2Db attributes to configure /// your model classes, but we strongly recommend that you use the Linq2Db <see cref="FluentMappingBuilder" /> to specify how model classes are mapped. /// </param> public static IDataProvider CreateSqlServerDataProvider(SqlServerVersion sqlServerVersion = SqlServerVersion.v2017, Action <MappingSchema>?createMappings = null) { var dataProvider = SqlServerTools.GetDataProvider(sqlServerVersion, SqlServerProvider.MicrosoftDataSqlClient); createMappings?.Invoke(dataProvider.MappingSchema); return(dataProvider); }
private static IDataProvider DetermineProvider(SqlConnection connection) { var sqlVersion = connection.ServerVersion.StartsWith("11.", System.StringComparison.Ordinal) ? SqlServerVersion.v2008 : SqlServerVersion.v2012; return(SqlServerTools.GetDataProvider(sqlVersion)); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) { loggerFactory.AddConsole(Configuration.GetSection("Logging")); loggerFactory.AddDebug(); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Home/Error"); } var connectionString = new SqlConnectionStringBuilder(Configuration["Data:DefaultConnection:ConnectionString"]) { InitialCatalog = "master" }.ConnectionString; using (var db = new DataConnection(SqlServerTools.GetDataProvider(), connectionString)) { try { var sql = "create database [" + new SqlConnectionStringBuilder(Configuration["Data:DefaultConnection:ConnectionString"]) .InitialCatalog + "]"; db.Execute(sql); } catch { // } } // Try to create tables using (var db = new ApplicationDataConnection()) { TryCreateTable <ApplicationUser>(db); TryCreateTable <LinqToDB.Identity.IdentityRole>(db); TryCreateTable <LinqToDB.Identity.IdentityUserClaim <string> >(db); TryCreateTable <LinqToDB.Identity.IdentityRoleClaim <string> >(db); TryCreateTable <LinqToDB.Identity.IdentityUserLogin <string> >(db); TryCreateTable <LinqToDB.Identity.IdentityUserRole <string> >(db); TryCreateTable <LinqToDB.Identity.IdentityUserToken <string> >(db); } app.UseStaticFiles(); app.UseAuthentication(); // To configure external authentication please see http://go.microsoft.com/fwlink/?LinkID=532715 app.UseMvc(routes => { routes.MapRoute( "default", "{controller=Home}/{action=Index}/{id?}"); }); }
public DbContext(ILogger logger, DbContextOptions options) : base( connectionString: options.ConnectionString, dataProvider: SqlServerTools.GetDataProvider( SqlServerVersion.v2017, SqlServerProvider.MicrosoftDataSqlClient)) { _logger = logger; }
public DataConnection CreateErmConnection() { var dataConnection = new DataConnection( SqlServerTools.GetDataProvider(SqlServerVersion.v2012), _connectionStringSettings.GetConnectionString(ErmConnectionStringIdentity.Instance, _tenantProvider.Current)); dataConnection.AddMappingSchema(Schema.Erm); return(dataConnection); }
public static IServiceCollection AddDatabaseContext(this IServiceCollection services, string connectionString, SqlServerVersion sqlServerVersion = SqlServerVersion.v2017) { var sqlServerDataProvider = (SqlServerDataProvider)SqlServerTools.GetDataProvider(sqlServerVersion, SqlServerProvider.MicrosoftDataSqlClient); CreateMappings(sqlServerDataProvider.MappingSchema); return(services.AddSingleton(sqlServerDataProvider) .AddTransient(c => new DataConnection(c.GetRequiredService <SqlServerDataProvider>(), new SqlConnection(connectionString), true)) .AddSingleton <Func <DataConnection> >(c => c.GetRequiredService <DataConnection>)); }
public void Compiled_Update_Nullable_Full() { for (var i = 0; i < _iterations; i++) { using (var db = new DataConnection(SqlServerTools.GetDataProvider(SqlServerVersion.v2008, SqlServerProvider.MicrosoftDataSqlClient), _cn)) { _compiledNullable(db, i); } } }
public void Test1(string context) { var connectionString = ConfigurationManager.ConnectionStrings["Northwind"].ConnectionString; using (var conn = new DataConnection(SqlServerTools.GetDataProvider(), connectionString)) { Assert.That(conn.Connection.State, Is.EqualTo(ConnectionState.Open)); Assert.That(conn.ConfigurationString, Is.Null); } }
public DataConnection CreateVrConnection() { var dataConnection = new DataConnection( SqlServerTools.GetDataProvider(SqlServerVersion.v2012), _connectionStringSettings.GetConnectionString(ValidationRulesConnectionStringIdentity.Instance, _tenantProvider.Current)); // Schema.Facts needed for Facts.EntityName table dataConnection.AddMappingSchema(Schema.Facts); dataConnection.AddMappingSchema(Schema.Messages); return(dataConnection); }
public static void Run(string[] args) { var serverName = "."; DataConnection.AddConfiguration( "Test", $"Server={serverName};Database=PerformanceTest;Trusted_Connection=True", SqlServerTools.GetDataProvider(SqlServerVersion.v2012)); DataConnection.DefaultConfiguration = "Test"; CreateDatabase(serverName); RunTests(); }
public void Update_Nullable_Full() { for (var i = 0; i < _iterations; i++) { using (var db = new DataConnection(SqlServerTools.GetDataProvider(SqlServerVersion.v2008, SqlServerProvider.MicrosoftDataSqlClient), _cn)) { db.GetTable <MyPOCON>() .Where(p => p.Code == "A" + i && p.Currency == "SUR") .Set(p => p.Weight, i * 10) .Set(p => p.Currency, "SUR") .Set(p => p.Value, i * i + 2) .Update(); } } }
public void Setup() { _cn = new MockDbConnection(new QueryResult() { Return = 1 }, ConnectionState.Open); _db = new DataConnection(SqlServerTools.GetDataProvider(SqlServerVersion.v2008, SqlServerProvider.MicrosoftDataSqlClient), _cn); _compiled = CompiledQuery.Compile <DataConnection, int, int>((ctx, i) => ctx.GetTable <MyPOCO>() .Where(p => p.Code == "A" + i && p.Currency == "SUR") .Set(p => p.Weight, i * 10) .Set(p => p.Currency, "SUR") .Set(p => p.Value, i * i + 2) .Update()); _compiledNullable = CompiledQuery.Compile <DataConnection, int, int>((ctx, i) => ctx.GetTable <MyPOCON>() .Where(p => p.Code == "A" + i && p.Currency == "SUR") .Set(p => p.Weight, i * 10) .Set(p => p.Currency, "SUR") .Set(p => p.Value, i * i + 2) .Update()); }
/// <summary> /// Return new instance of <see cref="SqlServerDataProvider"/> /// </summary> public IDataProvider GetDataProvider() { var sqlProvider = SqlServerTools.GetDataProvider(SqlServerVersion.v2017); return(sqlProvider); }
public DbContext(string connectionString) : base(SqlServerTools.GetDataProvider(), connectionString) { }
public DataConnectionFactory(IOptions <ConnectionStringSettings> settings) { DataConnection.AddConfiguration("Erm", settings.Value.Erm, SqlServerTools.GetDataProvider(SqlServerVersion.v2012)); _schema = CreateSchema(); }
/// <summary> /// Configure connection to use specific SQL Server provider, dialect and connection string. /// </summary> /// <param name="builder">Instance of <see cref="LinqToDbConnectionOptionsBuilder"/>.</param> /// <param name="connectionString">SQL Server connection string.</param> /// <param name="provider">SQL Server provider to use.</param> /// <param name="dialect">SQL Server dialect support level.</param> /// <returns>The builder instance so calls can be chained.</returns> public static LinqToDbConnectionOptionsBuilder UseSqlServer(this LinqToDbConnectionOptionsBuilder builder, string connectionString, SqlServerProvider provider, SqlServerVersion dialect) { return(builder.UseConnectionString(SqlServerTools.GetDataProvider(dialect, provider), connectionString)); }