public void ShouldBuildProperDDLForANewSqliteDatabase()
{
// Setup
string expectedDDL = "CREATE TABLE [Teachers] (" + _nl +
"[Id] blob PRIMARY KEY NOT NULL," + _nl +
"[TeacherName] text NOT NULL);" + _nl +
"CREATE TABLE [Courses] (" + _nl +
"[Id] blob PRIMARY KEY NOT NULL," + _nl +
"[CourseName] text NOT NULL," + _nl +
"[CourseDescription] text ," + _nl +
"[CourseTeacher] blob REFERENCES Teachers (Id) ON DELETE NO ACTION ON UPDATE NO ACTION NOT NULL," + _nl +
"[IsAvailable] integer NOT NULL DEFAULT(0));";
var dialect = new SqliteDialect();
var database = new Database("MyDatabase", dialect);
var teacher = database.AddTable("Teachers");
teacher.AddColumn("Id", typeof(Guid)).PrimaryKey().NotNullable();
teacher.AddColumn("TeacherName", typeof(String), 100).NotNullable();
var course = database.AddTable("Courses");
course.AddColumn("Id", typeof(Guid)).PrimaryKey().NotNullable();
course.AddColumn("CourseName", typeof(String), 100).NotNullable();
course.AddColumn("CourseDescription", typeof(String));
course.AddColumn("CourseTeacher", typeof(Guid)).ForeignKey("Teachers", "Id").NotNullable();
course.AddColumn("IsAvailable", typeof(bool)).NotNullable(false);
// Execute
var actualDDL = database.ToString();
// Assert
Assert.AreEqual(expectedDDL, actualDDL);
}
/// <summary>
/// 根据配置创建数据库连接
/// </summary>
/// <returns></returns>
public ISqlDialect CreateDialect()
{
ISqlDialect sqlDialect = null;
switch (_dbType)
{
case DBType.SqlServer:
sqlDialect = new SqlServerDialect();
break;
case DBType.MySql:
sqlDialect = new MySqlDialect();
break;
case DBType.Oracle:
sqlDialect = new OracleDialect();
break;
case DBType.SqlCe:
sqlDialect = new SqlCeDialect();
break;
case DBType.SQLite:
sqlDialect = new SqliteDialect();
break;
}
return(sqlDialect);
}
/// <summary>
/// 工厂模式 根据配置创建数据库
/// </summary>
/// <returns></returns>
public static ISqlDialect CreateSqlDialect()
{
ISqlDialect sqlDialect = null;
switch (PubConstant.DbType.ToLower())
{
case "mssql":
sqlDialect = new SqlServerDialect();
break;
case "mysql":
sqlDialect = new MySqlDialect();
break;
case "oracle":
sqlDialect = new OracleDialect();
break;
case "sqlce":
sqlDialect = new SqlCeDialect();
break;
case "sqlite":
sqlDialect = new SqliteDialect();
break;
}
return(sqlDialect);
}
public void GetColumnNameShouldThrowsExceptionIfSqlIsNullOrEmpty(string sql)
{
var dialect = new SqliteDialect();
Assert.Throws <ArgumentNullException>("columnName", () =>
{
dialect.GetColumnName(string.Empty, sql, string.Empty);
});
}
public void GetSetSql()
{
var dialect = new SqliteDialect();
var dictionary = new Dictionary <string, object>();
Assert.Equal("select * from TestEntity LIMIT @Offset, @Count", dialect.GetSetSql("select * from TestEntity", 1, 2, dictionary));
Assert.Equal(1, dictionary["@Offset"]);
Assert.Equal(2, dictionary["@Count"]);
}
public void GetSetSqlShouldThrowsExceptionIfParamsIsNullEmpty()
{
var dialect = new SqliteDialect();
Assert.Throws <ArgumentNullException>("parameters", () =>
{
dialect.GetSetSql("select * from TestEntity", 1, 1, null);
});
}
public void GetSetSqlShouldThrowsExceptionIfSqlIsNullOrEmpty(string sql)
{
var dialect = new SqliteDialect();
Assert.Throws <ArgumentNullException>("sql", () =>
{
dialect.GetSetSql(sql, 1, 1, null);
});
}
private Database CreateDatabase()
{
ISqlDialect sqlDialect = null;
IDbConnection connection = null;
switch (_dataBaseType.ToLower())
{
case "mysql":
{
connection = new MySqlConnection(_connectionString);
sqlDialect = new MySqlDialect();
}
break;
case "sqlserver":
{
connection = new SqlConnection(_connectionString);
sqlDialect = new SqlServerDialect();
}
break;
case "oracle":
{
}
break;
case "sqlite":
{
//connection = new SQLiteConnection(_connectionString);
sqlDialect = new SqliteDialect();
}
break;
default:
break;
}
var config = new DapperExtensionsConfiguration(typeof(AutoClassMapper <>), new List <Assembly>(), sqlDialect);
var sqlGenerator = new SqlGeneratorImpl(config);
//if (connection.State != ConnectionState.Open)
// connection.Open();
return(new Database(connection, sqlGenerator));
}
public static RuntimeBuilder AddSqliteRuntime(this RuntimeBuilder builder,
string connectionString,
ConnectionScope scope = ConnectionScope.ByRequest,
Action <SqliteOptions> configureDatabase = null)
{
builder.Services.AddTypeResolver();
void ConfigureDatabase(SqliteOptions o)
{
configureDatabase?.Invoke(o);
}
builder.Services.Configure <SqliteOptions>(ConfigureDatabase);
var serviceProvider = builder.Services.BuildServiceProvider();
var options = serviceProvider.GetService <IOptions <SqliteOptions> >()?.Value ?? new SqliteOptions();
configureDatabase?.Invoke(options);
var dialect = new SqliteDialect();
SqlBuilder.Dialect = dialect;
builder.AddSqlRuntimeStores <SqliteConnectionFactory>(connectionString, scope, OnCommand(), OnConnection);
builder.Services.AddMetrics();
builder.Services.TryAddSingleton <ISqlDialect>(dialect);
builder.Services.TryAddSingleton(dialect);
builder.Services.TryAddSingleton <IDataBatchOperation <SqliteOptions>, SqliteBatchDataOperation>();
var runtimeOptions = serviceProvider.GetRequiredService <IOptions <RuntimeOptions> >().Value;
MigrateToLatest(connectionString, runtimeOptions);
return(builder);
}
public static ISqlDialect ConvertESqlDialect(ESqlDialect sqlDialect)
{
ISqlDialect SqlDialect = null;
switch (sqlDialect)
{
case ESqlDialect.DB2:
SqlDialect = new DB2Dialect();
break;
case ESqlDialect.MySQL:
SqlDialect = new MySqlDialect();
break;
case ESqlDialect.Oracle:
SqlDialect = new OracleDialect();
break;
case ESqlDialect.PostgreSql:
SqlDialect = new PostgreSqlDialect();
break;
case ESqlDialect.SqlCe:
SqlDialect = new SqlCeDialect();
break;
case ESqlDialect.Sqlite:
SqlDialect = new SqliteDialect();
break;
case ESqlDialect.SqlServer:
SqlDialect = new SqlServerDialect();
break;
}
return(SqlDialect);
}
public void GetColumnName()
{
var dialect = new SqliteDialect();
Assert.Equal("name AS \"first_name\"", dialect.GetColumnName("pr", "name", "first_name"));
}
public SqliteDialectFixtureBase()
{
Dialect = new SqliteDialect();
}
public static void QuoteIdentifier_GivenNullOrWhiteSpaceIdentifier_ThrowsArgumentNullException(string identifier)
{
var dialect = new SqliteDialect();
Assert.That(() => dialect.QuoteIdentifier(identifier), Throws.ArgumentNullException);
}
public void getDb(String dbName = null)
{
SqlDialectBase dialect = null;
if (String.IsNullOrEmpty(dbName))
{
dbname = ConfigFileTool.SAPGlobalSettings.GetCodeTemplateDb();
}
else
{
dbname = dbName;
}
if (string.IsNullOrEmpty(dbname))
{
throw new Exception("Con't get the db connection");
}
netlib = new netlib7(dbname);
connection = netlib.CreateConnection();
switch (netlib.ProviderType)
{
case netlib7.ProviderTypes.Oracle:
break;
case netlib7.ProviderTypes.SqlServer:
dialect = new SqlServerDialect();
break;
case netlib7.ProviderTypes.MsAccess:
dialect = new SqlCeDialect();
break;
case netlib7.ProviderTypes.MySql:
dialect = new MySqlDialect();
break;
case netlib7.ProviderTypes.PostgreSQL:
break;
case netlib7.ProviderTypes.OleDB:
dialect = new SqlCeDialect();
break;
case netlib7.ProviderTypes.SQLite:
dialect = new SqliteDialect();
break;
case netlib7.ProviderTypes.Unknown:
break;
default:
break;
}
var config = new DapperExtensionsConfiguration(typeof(AutoClassMapper <>), new List <Assembly>(), dialect);
var sqlGenerator = new SqlGeneratorImpl(config);
Db = new Database(connection, sqlGenerator);
}
static SqliteBulkCopy()
{
Dialect = new SqliteDialect();
}
public static IdentityBuilder AddSqliteIdentityStore <TKey, TUser, TRole, TTenant>(
this IdentityBuilder identityBuilder,
string connectionString, ConnectionScope scope = ConnectionScope.ByRequest,
Action <SqliteOptions> configureDatabase = null)
where TKey : IEquatable <TKey>
where TUser : IdentityUserExtended <TKey>
where TRole : IdentityRoleExtended <TKey>
where TTenant : IdentityTenant <TKey>
{
identityBuilder.Services.AddSingleton <ITypeRegistry, TypeRegistry>();
var dialect = new SqliteDialect();
var builder = new SqliteConnectionStringBuilder(connectionString);
void ConfigureDatabase(SqliteOptions o)
{
configureDatabase?.Invoke(o);
}
identityBuilder.Services.Configure <SqliteOptions>(ConfigureDatabase);
var serviceProvider = identityBuilder.Services.BuildServiceProvider();
var options = serviceProvider.GetService <IOptions <SqliteOptions> >()?.Value ?? new SqliteOptions();
configureDatabase?.Invoke(options);
identityBuilder.AddSqlStores <SqliteConnectionFactory, TKey, TUser, TRole, TTenant>(connectionString, scope,
OnCommand <TKey>(), OnConnection);
identityBuilder.Services.AddSingleton(dialect);
SqlBuilder.Dialect = dialect;
SimpleDataDescriptor.TableNameConvention = s =>
{
switch (s)
{
case nameof(IdentityRoleExtended):
return("AspNetRoles");
case nameof(IdentityUserExtended):
return("AspNetUsers");
case nameof(IdentityTenant):
return("AspNetTenants");
default:
return(s);
}
};
DescriptorColumnMapper.AddTypeMap <TUser>(StringComparer.Ordinal);
DescriptorColumnMapper.AddTypeMap <TRole>(StringComparer.Ordinal);
DescriptorColumnMapper.AddTypeMap <TTenant>(StringComparer.Ordinal);
identityBuilder.Services.AddMetrics();
identityBuilder.Services.AddSingleton(dialect);
identityBuilder.Services.AddSingleton <IQueryableProvider <TUser>, NoQueryableProvider <TUser> >();
identityBuilder.Services.AddSingleton <IQueryableProvider <TRole>, NoQueryableProvider <TRole> >();
identityBuilder.Services.AddSingleton <IQueryableProvider <TTenant>, NoQueryableProvider <TTenant> >();
var identityOptions = serviceProvider.GetRequiredService <IOptions <IdentityOptionsExtended> >().Value;
MigrateToLatest <TKey>(connectionString, identityOptions, options);
return(identityBuilder);
}
public void Setup()
{
Dialect = new SqliteDialect();
}
public static void QuoteName_GivenNullOrWhiteSpaceName_ThrowsArgumentNullException(string name)
{
var dialect = new SqliteDialect();
Assert.That(() => dialect.QuoteName(name), Throws.ArgumentNullException);
}
