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));
}
