public Migrator(
[NotNull] IMigrationsAssembly migrationsAssembly,
[NotNull] IHistoryRepository historyRepository,
[NotNull] IDatabaseCreator databaseCreator,
[NotNull] IMigrationsSqlGenerator migrationsSqlGenerator,
[NotNull] ISqlCommandBuilder sqlCommandBuilder,
[NotNull] IRelationalConnection connection,
[NotNull] ISqlGenerator sqlGenerator,
[NotNull] ILogger<Migrator> logger,
[NotNull] IDatabaseProviderServices providerServices)
{
Check.NotNull(migrationsAssembly, nameof(migrationsAssembly));
Check.NotNull(historyRepository, nameof(historyRepository));
Check.NotNull(databaseCreator, nameof(databaseCreator));
Check.NotNull(migrationsSqlGenerator, nameof(migrationsSqlGenerator));
Check.NotNull(sqlCommandBuilder, nameof(sqlCommandBuilder));
Check.NotNull(connection, nameof(connection));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
Check.NotNull(logger, nameof(logger));
Check.NotNull(providerServices, nameof(providerServices));
_migrationsAssembly = migrationsAssembly;
_historyRepository = historyRepository;
_databaseCreator = (IRelationalDatabaseCreator)databaseCreator;
_migrationsSqlGenerator = migrationsSqlGenerator;
_sqlCommandBuilder = sqlCommandBuilder;
_sqlCommandBuilder = sqlCommandBuilder;
_connection = connection;
_sqlGenerator = sqlGenerator;
_logger = logger;
_activeProvider = providerServices.InvariantName;
}
public Migrator(
[NotNull] MigrationAssembly migrationAssembly,
[NotNull] IHistoryRepository historyRepository,
[NotNull] IDataStoreCreator dataStoreCreator,
[NotNull] IMigrationSqlGenerator migrationSqlGenerator,
[NotNull] SqlStatementExecutor executor,
[NotNull] IRelationalConnection connection,
[NotNull] IModelDiffer modelDiffer,
[NotNull] IModel model,
[NotNull] MigrationIdGenerator idGenerator,
[NotNull] ISqlGenerator sqlGenerator)
{
Check.NotNull(migrationAssembly, nameof(migrationAssembly));
Check.NotNull(historyRepository, nameof(historyRepository));
Check.NotNull(dataStoreCreator, nameof(dataStoreCreator));
Check.NotNull(migrationSqlGenerator, nameof(migrationSqlGenerator));
Check.NotNull(executor, nameof(executor));
Check.NotNull(connection, nameof(connection));
Check.NotNull(modelDiffer, nameof(modelDiffer));
Check.NotNull(model, nameof(model));
Check.NotNull(idGenerator, nameof(idGenerator));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
_migrationAssembly = migrationAssembly;
_historyRepository = historyRepository;
_dataStoreCreator = (IRelationalDataStoreCreator)dataStoreCreator;
_migrationSqlGenerator = migrationSqlGenerator;
_executor = executor;
_connection = connection;
_modelDiffer = modelDiffer;
_model = model;
_idGenerator = idGenerator;
_sqlGenerator = sqlGenerator;
}
/// <summary>
/// 初始化 <see cref="Database"/> 类的新实例。
/// </summary>
/// <param name="loggerFactory">日志工厂接口。</param>
/// <param name="factory">数据库提供者工厂类。</param>
/// <param name="options">配置选项。</param>
/// <param name="sqlGenerator">SQL辅助接口。</param>
protected Database(ILoggerFactory loggerFactory, DbProviderFactory factory, IOptions<DataSourceOptions> options, ISqlGenerator sqlGenerator)
{
_factory = factory;
_sqlGenerator = sqlGenerator;
_connectionString = options.Value.ConnectionString;
_prefix = options.Value.Prefix.EscapePrefix();
Logger = loggerFactory.CreateLogger<Database>();
}
protected DrapperManager(ISqlGenerator generator, IDbConnection dbConnection, ISqlDialect dialect)
{
Dialect = dialect;
Generator = generator;
DbConnection = dbConnection;
Database = new Database(dbConnection, generator);
Init();
}
void test(string tableText, string expected, ISqlGenerator sqlGenerator)
{
SqlGenerator.G.SqlGenerator = sqlGenerator;
ParseTable parseTable = new ParseTable();
Table table = parseTable.ParseTableData(tableText);
string result = table.ToCreateScript();
if (result != expected)
throw new ApplicationException("Test failed");
}
public SqliteQuerySqlGeneratorFactory(
[NotNull] IRelationalCommandBuilderFactory commandBuilderFactory,
[NotNull] ISqlGenerator sqlGenerator,
[NotNull] IParameterNameGeneratorFactory parameterNameGeneratorFactory)
{
Check.NotNull(commandBuilderFactory, nameof(commandBuilderFactory));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
Check.NotNull(parameterNameGeneratorFactory, nameof(parameterNameGeneratorFactory));
_commandBuilderFactory = commandBuilderFactory;
_sqlGenerator = sqlGenerator;
_parameterNameGeneratorFactory = parameterNameGeneratorFactory;
}
public string GetSql(ISqlGenerator sqlGenerator, IDictionary<string, object> parameters)
{
string seperator = Operator == GroupOperator.And ? " AND " : " OR ";
return "(" + Predicates.Aggregate(new StringBuilder(),
(sb, p) => (sb.Length == 0 ? sb : sb.Append(seperator)).Append(p.GetSql(sqlGenerator, parameters)),
sb =>
{
var s = sb.ToString();
if (s.Length == 0) return sqlGenerator.Configuration.Dialect.EmptyExpression;
return s;
}
) + ")";
}
public SqliteModificationCommandBatchFactory(
[NotNull] IRelationalCommandBuilderFactory commandBuilderFactory,
[NotNull] ISqlGenerator sqlGenerator,
[NotNull] IUpdateSqlGenerator updateSqlGenerator,
[NotNull] IRelationalValueBufferFactoryFactory valueBufferFactoryFactory)
{
Check.NotNull(commandBuilderFactory, nameof(commandBuilderFactory));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
Check.NotNull(updateSqlGenerator, nameof(updateSqlGenerator));
Check.NotNull(valueBufferFactoryFactory, nameof(valueBufferFactoryFactory));
_commandBuilderFactory = commandBuilderFactory;
_sqlGenerator = sqlGenerator;
_updateSqlGenerator = updateSqlGenerator;
_valueBufferFactoryFactory = valueBufferFactoryFactory;
}
protected virtual string GetColumnName(Type entityType, ISqlGenerator sqlGenerator, string propertyName)
{
IClassMapper map = sqlGenerator.Configuration.GetMap(entityType);
if (map == null)
{
throw new NullReferenceException(string.Format("Map was not found for {0}", entityType));
}
IPropertyMap propertyMap = map.Properties.SingleOrDefault(p => p.Name == propertyName);
if (propertyMap == null)
{
throw new NullReferenceException(string.Format("{0} was not found for {1}", propertyName, entityType));
}
return sqlGenerator.GetColumnName(map, propertyMap, false);
}
public SqlServerModificationCommandBatchFactory(
[NotNull] IRelationalCommandBuilderFactory commandBuilderFactory,
[NotNull] ISqlGenerator sqlGenerator,
[NotNull] ISqlServerUpdateSqlGenerator updateSqlGenerator,
[NotNull] IRelationalValueBufferFactoryFactory valueBufferFactoryFactory,
[NotNull] IDbContextOptions options)
{
Check.NotNull(commandBuilderFactory, nameof(commandBuilderFactory));
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
Check.NotNull(updateSqlGenerator, nameof(updateSqlGenerator));
Check.NotNull(valueBufferFactoryFactory, nameof(valueBufferFactoryFactory));
Check.NotNull(options, nameof(options));
_commandBuilderFactory = commandBuilderFactory;
_sqlGenerator = sqlGenerator;
_updateSqlGenerator = updateSqlGenerator;
_valueBufferFactoryFactory = valueBufferFactoryFactory;
_options = options;
}
public virtual void SetSqlGenerator()
{
Generator = new SqlServerSqlGenerator();
}
/// <summary>
/// Gets the join type value.
/// </summary>
/// <param name="j">The j.</param>
/// <param name="generator"></param>
/// <returns></returns>
public static string GetJoinTypeValue(ISqlGenerator generator, JoinType j)
{
string result = generator.sqlFragment.INNER_JOIN;
switch(j)
{
case JoinType.Outer:
result = generator.sqlFragment.OUTER_JOIN;
break;
case JoinType.LeftInner:
/*
* 修 改 人：Empty（AllEmpty）
* QQ 群：327360708
* 博客地址：http://www.cnblogs.com/EmptyFS/
* 修改时间：2013-09-23
* 修改说明：将generator.sqlFragment.LEFT_INNER_JOIN改为generator.sqlFragment.LEFT_JOIN
* 修改后生成的SQL外连接语句就从错误的LEFT INNER JOIN变为LEFT JOIN
*********************************************/
result = generator.sqlFragment.LEFT_JOIN;
break;
case JoinType.LeftOuter:
result = generator.sqlFragment.LEFT_OUTER_JOIN;
break;
case JoinType.RightInner:
/*
* 修 改 人：Empty（AllEmpty）
* QQ 群：327360708
* 博客地址：http://www.cnblogs.com/EmptyFS/
* 修改时间：2013-09-23
* 修改说明：将generator.sqlFragment.RIGHT_INNER_JOIN改为generator.sqlFragment.RIGHT_JOIN
* 修改后生成的SQL外连接语句就从错误的RIGHT INNER JOIN变为RIGHT JOIN
*********************************************/
result = generator.sqlFragment.RIGHT_JOIN;
break;
case JoinType.RightOuter:
result = generator.sqlFragment.RIGHT_OUTER_JOIN;
break;
case JoinType.Cross:
result = generator.sqlFragment.CROSS_JOIN;
break;
case JoinType.NotEqual:
result = generator.sqlFragment.UNEQUAL_JOIN;
break;
}
return result;
}
//NOTE: Because this is a "Dependency Injection Oriented Package"
//we need to pass the database connection and the SQL Generator as parameters
public ObuhvatSektoraRepository(OracleConnection connection,
ISqlGenerator <ObuhvatSektora> sqlGenerator)
: base(connection, sqlGenerator)
{
}
public PackageWriter([NotNull] IFileSystem fileSystemProvider, [NotNull] ISqlGenerator sqlGenerator, [NotNull] string outputPath)
{
this.fileSystemProvider = fileSystemProvider;
this.sqlGenerator = sqlGenerator;
this.outputPath = outputPath;
}
/// <summary>
/// Initializes a new instance of the <see cref="DapperAsyncImplementor"/> class.
/// </summary>
/// <param name="sqlGenerator">The SQL generator.</param>
public DapperAsyncImplementor(ISqlGenerator sqlGenerator)
: base(sqlGenerator)
{
}
private void readUI()
{
SelectedGenerator = ((SqlGeneratorItem)cmbGenerator.SelectedItem).Generator;
selectedTypeMap = ((TypeMapItem)cmbTypeMap.SelectedItem).TypeMap;
SelectedGenerator.TypeMap = selectedTypeMap;
}
/// <summary>
///
/// </summary>
/// <param name="connection"></param>
protected DataRepository(IDbConnection connection, ISqlGenerator <TEntity> sqlGenerator)
: base(connection)
{
SqlGenerator = sqlGenerator;
}
protected MigrationSqlGenerator([NotNull] ISqlGenerator sqlGenerator)
{
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
_sql = sqlGenerator;
}
/// <summary>
/// Constructor
/// </summary>
public DapperRepository(IDbConnection connection, ISqlGenerator <TEntity> sqlGenerator)
: base(connection, sqlGenerator)
{
}
/// <summary>
/// Constructor
/// </summary>
public DapperRepository(IDbConnection connection, IMapper mapper, ISqlGenerator <TEntity> sqlGenerator)
{
Connection = connection;
SqlGenerator = sqlGenerator;
_mapper = mapper;
}
/// <summary>
/// Constructor
/// </summary>
public DapperRepository(IDbConnection connection, SqlGeneratorConfig config)
{
Connection = connection;
SqlGenerator = new SqlGenerator <TEntity>(config);
}
/// <summary>
/// Constructor
/// </summary>
public DapperRepository(IDbConnection connection, ESqlConnector sqlConnector)
{
Connection = connection;
SqlGenerator = new SqlGenerator <TEntity>(sqlConnector);
}
/// <summary>
/// Constructor
/// </summary>
public DapperRepository(IDbConnection connection)
{
Connection = connection;
SqlGenerator = new SqlGenerator <TEntity>(ESqlConnector.MSSQL);
}
/// <summary>
/// Generates a SELECT query
/// </summary>
/// <param name="criteria"></param>
/// <returns></returns>
internal ExecutionQuery GenerateWithoutJoin(QueryCriteria criteria)
{
ISqlGenerator isql = null;
List <IDataParameter> listParameters = null;
ExecutionQuery execQuery;
SqlGenerator generator = new SqlGenerator();
DataFactory factory = new DataFactory();
try
{
listParameters = new List <IDataParameter>();
StringBuilder sbuild = new StringBuilder();
execQuery = new ExecutionQuery();
if (generatorType == QueryCriteriaGeneratorType.Select)
{
execQuery = generator.GenerateSelectQuery(DatabaseServer.Access, criteria);
}
else if (generatorType == QueryCriteriaGeneratorType.Update)
{
execQuery = generator.GenerateUpdateQuery(DatabaseServer.Access, criteria.TableName, criteria.Fields, false);
}
else if (generatorType == QueryCriteriaGeneratorType.Delete)
{
execQuery = generator.GenerateDeleteQuery(DatabaseServer.Access, criteria.TableName);
}
//add to the intermediary objects
if (execQuery.Parameters != null)
{
foreach (IDataParameter var in execQuery.Parameters)
{
listParameters.Add(var);
}
}
sbuild.Append(execQuery.Query);
//initialize generator
isql = factory.InitializeSqlGenerator(DatabaseServer.Access);
//append where clause
sbuild.Append(" WHERE ");
//generate the condition based on criteria
string condition = GenerateCondition(criteria.TableName, criteria.CriteriaConditions, ref sbuild, ref listParameters);
//more checks
if (sbuild.ToString().EndsWith(" WHERE ") && condition.StartsWith(" ORDER BY "))
{
if (condition.StartsWith(" ORDER BY"))
{
sbuild.Remove(sbuild.Length - WHERE_FIELD_LENGTH, WHERE_FIELD_LENGTH);
}
}
sbuild.Append(condition);
//last check to prevent invalid sql queries
if (sbuild.ToString().EndsWith(" WHERE "))
{
sbuild.Remove(sbuild.Length - WHERE_FIELD_LENGTH, WHERE_FIELD_LENGTH);
}
execQuery = new ExecutionQuery();
execQuery.Query = sbuild.ToString();
IDataParameter[] pmc = new IDataParameter[listParameters.Count];
listParameters.CopyTo(pmc);
execQuery.Parameters = pmc;
return(execQuery);
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (listParameters != null)
{
listParameters.Clear();
listParameters = null;
}
}
}
//NOTE: Because this is a "Dependency Injection Oriented Package"
//we need to pass the database connection and the SQL Generator as parameters
public HkoSifreRepository(OracleConnection connection, ISqlGenerator <HkoSifre> sqlGenerator)
: base(connection, sqlGenerator)
{
}
public TestModificationCommandBatchFactory(
IRelationalCommandBuilderFactory commandBuilderfactory,
ISqlGenerator sqlGenerator,
IUpdateSqlGenerator updateSqlGenerator,
IRelationalValueBufferFactoryFactory valueBufferFactoryFactory)
{
_commandBuilderFactory = commandBuilderfactory;
_sqlGenerator = sqlGenerator;
_updateSqlGenerator = updateSqlGenerator;
_valueBufferFactoryFactory = valueBufferFactoryFactory;
}
public ConcreteMigrationSqlGenerator(
IRelationalCommandBuilderFactory commandBuilderFactory,
ISqlGenerator sqlGenerator,
IRelationalTypeMapper typeMapper,
IRelationalAnnotationProvider annotations)
: base(commandBuilderFactory, sqlGenerator, typeMapper, annotations)
{
}
/// <summary>
/// Builds the SQL statement.
/// </summary>
/// <returns></returns>
public string BuildSqlStatement(MigrationDirection direction)
{
if (Provider == null)
{
Provider = DataService.Provider;
}
ISqlGenerator generator = DataService.GetGenerator(Provider);
StringBuilder sql = new StringBuilder();
// based on direction build migration steps only when dealing with a
// decendent class, there is no overridden Up or Down if doing a
// migrate on dispose style so the step.Clear() would destroy all
// our hard work.
if (!migrateOnDispose)
{
steps.Clear();
switch (direction)
{
case MigrationDirection.Up:
Up();
break;
case MigrationDirection.Down:
Down();
break;
}
}
//build sql
foreach (MigrationStep step in steps)
{
switch (step.StepType)
{
case MigrationStepType.CreateTable:
// need to make sure this table has a pk defined
// if not, add one
// we'll do yer job for ya :)
if (step.Table.PrimaryKey == null)
{
step.Table.AddPrimaryKeyColumn();
}
sql.Append(generator.BuildCreateTableStatement(step.Table));
break;
case MigrationStepType.DropTable:
sql.Append(generator.BuildDropTableStatement(step.Table));
break;
case MigrationStepType.AddForeignKey:
sql.Append(generator.BuildForeignKeyStatement(step.Column, step.Column2));
break;
case MigrationStepType.DropForeignKey:
sql.Append(generator.BuildForeignKeyDropStatement(step.Column, step.Column2));
break;
case MigrationStepType.AddColumn:
sql.Append(generator.BuildAddColumnStatement(step.Table, step.Column));
break;
case MigrationStepType.AlterColumn:
sql.Append(generator.BuildAlterColumnStatement(step.Column));
break;
case MigrationStepType.DropColumn:
sql.Append(generator.BuildDropColumnStatement(step.Table, step.Column));
break;
case MigrationStepType.ExecuteSql:
sql.Append(step.Sql);
break;
default:
break;
}
sql.Append(";\r\n");
}
return(sql.ToString());
}
/// <summary>
/// 初始化类<see cref="QueryContext{TModel}"/>。
/// </summary>
/// <param name="model">模型接口。</param>
/// <param name="sqlHelper">SQL辅助接口。</param>
/// <param name="visitorFactory">表达式解析工厂接口。</param>
/// <param name="sqlGenerator">SQL脚本生成接口。</param>
/// <param name="db">数据库接口。</param>
public QueryContext(IModel model, ISqlHelper sqlHelper, IExpressionVisitorFactory visitorFactory, ISqlGenerator sqlGenerator, IDatabase db)
{
_visitorFactory = visitorFactory;
_sqlGenerator = sqlGenerator;
_db = db;
Model = model;
SqlHelper = sqlHelper;
Entity = Model.GetEntity(typeof(TModel));
}
//NOTE: Because this is a "Dependency Injection Oriented Package"
//we need to pass the database connection and the SQL Generator as parameters
public Nkz7Repository(OracleConnection connection, ISqlGenerator <Nkz7> sqlGenerator)
: base(connection, sqlGenerator)
{
}
public Command(ICommandManager cmdManager, ISqlGenerator <T> sqlGenerator)
{
_cmdManager = cmdManager;
_sqlGenerator = sqlGenerator;
}
public GenericSqlGenerator(ISqlGenerator concreteGenerator, MessageAdapter messages)
{
this.concreteGenerator = concreteGenerator;
this.messages = messages;
}
public SqLite3Executer(NamedConnectionString connectionString, ISqlGenerator sqlGenerator = null)
: base(connectionString, sqlGenerator)
{
}
public DapperImplementor(ISqlGenerator sqlGenerator, DataBaseType dbType)
{
SqlGenerator = sqlGenerator;
DbType = dbType;
}
protected ModificationCommandBatch([NotNull] ISqlGenerator sqlGenerator)
{
Check.NotNull(sqlGenerator, nameof(sqlGenerator));
SqlGenerator = sqlGenerator;
}
public abstract string GetSql(ISqlGenerator sqlGenerator, IDictionary <string, object> parameters);
public SchemaTransitionGenerator(ISqlGenerator concreteGenerator, NDO.Mapping.NDOMapping mappings)
{
provider = NDOProviderFactory.Instance[concreteGenerator.ProviderName];
this.concreteGenerator = concreteGenerator;
this.mappings = mappings;
}
/// <summary>
/// 初始化类<see cref="SqlServerMigrationsSqlGenerator"/>。
/// </summary>
/// <param name="sql">SQL辅助实例。</param>
public SqlServerMigrationsSqlGenerator(ISqlGenerator sql) : base(sql)
{
}
public AccountRepository(IDbConnection connection, ISqlGenerator <Account> sqlGenerator) : base(connection, sqlGenerator)
{
}
public DapperImplementor(ISqlGenerator sqlGenerator)
{
SqlGenerator = sqlGenerator;
}
public SqliteMigrationSqlGenerator(
[NotNull] ISqlGenerator sqlGenerator)
: base(sqlGenerator)
{
_sql = sqlGenerator;
}
public StudentRepository(IDbConnection connection, ISqlGenerator <Students> sqlGenerator)
: base(connection, sqlGenerator)
{
}
public SqlGeneratorItem(string Name, ISqlGenerator Generator)
{
this.Name = Name;
this.Generator = Generator;
}
/// <summary>
/// Generates the sql query condition
/// </summary>
/// <param name="tableName">Name of the datbase table</param>
/// <param name="conditions">Criteria conditions </param>
/// <param name="sbSqlHeader">StringBuilder which contains the SELECT part of the sql query build so far</param>
/// <param name="listParameters">List with used parameters</param>
/// <returns></returns>
internal string GenerateCondition(string tableName, CriteriaCondition[] conditions, ref StringBuilder sbSqlHeader, ref List <IDataParameter> listParameters)
{
//keeps the order by part of the query
StringBuilder sbOrderByCriteria = new StringBuilder();
//holds the generated query
StringBuilder sbuild = new StringBuilder();
ISqlGenerator isql = null;
SqlGenerator generator = new SqlGenerator();
DataConvertor converter = new DataConvertor();
//temporary vars
string fieldName = string.Empty;
int index = -1;
string tempString = string.Empty;
List <string> listParameterNames = null;
DataFactory factory = new DataFactory();
try
{
listParameterNames = new List <string>();
//initialize generator
isql = factory.InitializeSqlGenerator(DatabaseServer.Access);
//generate conditions
for (int i = 0; i < conditions.Length; i++)
{
//check if we generate "AND" operator
if (i > 0)
{
if ((conditions[i].CriteriaOperator != CriteriaOperator.OrderBy) && (conditions[i].CriteriaOperator != CriteriaOperator.Or) &&
(conditions[i - 1].CriteriaOperator != CriteriaOperator.Or) && (conditions[i - 1].CriteriaOperator != CriteriaOperator.Not))
{
sbuild.Append(" AND ");
}
}
DatabaseField field = conditions[i].Field;
switch (conditions[i].CriteriaOperator)
{
case CriteriaOperator.Between:
//here we must have 2 parameters with two diffferent values and name. These
//parameters must be generated based on a single name.
IDataParameter paramBetweenFirst = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
IDataParameter paramBetweenSecond = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
paramBetweenFirst.ParameterName = paramBetweenFirst.ParameterName + "First";
paramBetweenSecond.ParameterName = paramBetweenSecond.ParameterName + "Second";
//set the parameter's value and add it to the list
paramBetweenFirst.Value = conditions[i].Values[0];
listParameters.Add(paramBetweenFirst);
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + conditions[i].Field.fieldName + " BETWEEN " +
isql.GetValue(paramBetweenFirst));
sbuild.Append(" AND ");
//set the value of the second parameter
paramBetweenSecond.Value = conditions[i].Values[1];
listParameters.Add(paramBetweenSecond);
sbuild.Append(isql.GetValue(paramBetweenSecond));
break;
case CriteriaOperator.Not:
sbuild.Append(" NOT");
break;
case CriteriaOperator.Different:
field.fieldValue = conditions[i].Values[0];
IDataParameter paramDifferent = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
listParameters.Add(paramDifferent);
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + "<>" + isql.GetValue(paramDifferent));
break;
case CriteriaOperator.Like:
field.fieldValue = "*" + conditions[i].Values[0] + "*";
IDataParameter paramLike = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
listParameters.Add(paramLike);
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " LIKE " + isql.GetValue(paramLike));
break;
case CriteriaOperator.LikeEnd:
field.fieldValue = "*" + conditions[i].Values[0];
IDataParameter paramLikeEnd = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
listParameters.Add(paramLikeEnd);
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " LIKE " + isql.GetValue(paramLikeEnd));
break;
case CriteriaOperator.LikeStart:
field.fieldValue = conditions[i].Values[0] + "*";
IDataParameter paramLikeStart = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
listParameters.Add(paramLikeStart);
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " LIKE " + isql.GetValue(paramLikeStart));
break;
case CriteriaOperator.Equality:
field.fieldValue = conditions[i].Values[0];
IDataParameter paramEquality = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
listParameters.Add(paramEquality);
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + "=" + isql.GetValue(paramEquality));
break;
case CriteriaOperator.IsNull:
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " is null");
break;
case CriteriaOperator.IsNotNull:
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " is not null");
break;
case CriteriaOperator.Or:
sbuild.Append(" OR");
break;
case CriteriaOperator.Smaller:
field.fieldValue = conditions[i].Values[0];
IDataParameter paramSmaller = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
listParameters.Add(paramSmaller);
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " < " + isql.GetValue(paramSmaller));
break;
case CriteriaOperator.SmallerOrEqual:
field.fieldValue = conditions[i].Values[0];
IDataParameter paramSmallerOrEqual = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
listParameters.Add(paramSmallerOrEqual);
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " <= " + isql.GetValue(paramSmallerOrEqual));
break;
case CriteriaOperator.Higher:
field.fieldValue = conditions[i].Values[0];
IDataParameter paramHigher = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
listParameters.Add(paramHigher);
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " > " + isql.GetValue(paramHigher));
break;
case CriteriaOperator.HigherOrEqual:
field.fieldValue = conditions[i].Values[0];
IDataParameter paramHigherOrEqual = converter.ConvertToDataParameter(DatabaseServer.Access, tableName, field, ref listParameterNames);
listParameters.Add(paramHigherOrEqual);
sbuild.Append(" " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " >= " + isql.GetValue(paramHigherOrEqual));
break;
case CriteriaOperator.OrderBy:
if (sbOrderByCriteria.Length == 0)
{
//add the operator for the first criteria
sbOrderByCriteria.Append("ORDER BY " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " " + conditions[i].Values[0]);
}
else
{
//add "," for the subsequent criterias
sbOrderByCriteria.Append(", " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + field.fieldName + " " + conditions[i].Values[0]);
}
break;
//NOTE : DISTICT requires modification of the sql header. Also DISTINCT clause requires that
//the distinct field should be the first one in the list.
case CriteriaOperator.Distinct:
//get the field
fieldName = generator.GetTableName(DatabaseServer.Access, tableName) + "." + conditions[i].Field.fieldName;
//we have the field name now search for it in the fields list
index = sbSqlHeader.ToString().IndexOf(fieldName);
//now remove the field from the list.
if (index == -1)
{
throw new ArgumentException("Invalid Distinct clause");
}
tempString = sbSqlHeader.ToString();
tempString = tempString.Remove(index, fieldName.Length);
//add it at the beginning of the select
tempString = tempString.Insert(SELECT_FIELD_LENGTH, " distinct " + generator.GetTableName(DatabaseServer.Access, tableName) + "." + conditions[i].Field.fieldName);
sbSqlHeader.Remove(0, sbSqlHeader.Length);
sbSqlHeader.Append(tempString);
break;
//NOTE: MAX fields must be after SELECT statement
case CriteriaOperator.Max:
//get the field
fieldName = generator.GetTableName(DatabaseServer.Access, tableName) + "." + conditions[i].Field.fieldName;
//we have the field name now search for it in the fields list
index = sbSqlHeader.ToString().IndexOf(fieldName);
//now remove the field from the list.
if (index == -1)
{
throw new ArgumentException("Invalid MAX clause");
}
tempString = sbSqlHeader.ToString();
tempString = tempString.Remove(index, fieldName.Length);
//add it at the beginning of the select
tempString = tempString.Insert(SELECT_FIELD_LENGTH, " max(" + generator.GetTableName(DatabaseServer.Access, tableName) + "." + conditions[i].Field.fieldName + ")");
sbSqlHeader.Remove(0, sbSqlHeader.Length);
sbSqlHeader.Append(tempString);
break;
//NOTE: MIN fields must be after SELECT statement
case CriteriaOperator.Min:
//get the field
fieldName = generator.GetTableName(DatabaseServer.Access, tableName) + "." + conditions[i].Field.fieldName;
//we have the field name now search for it in the fields list
index = sbSqlHeader.ToString().IndexOf(fieldName);
//now remove the field from the list.
if (index == -1)
{
throw new ArgumentException("Invalid MIN clause");
}
tempString = sbSqlHeader.ToString();
tempString = tempString.Remove(index, fieldName.Length);
//add it at the beginning of the select
tempString = tempString.Insert(SELECT_FIELD_LENGTH, " min(" + generator.GetTableName(DatabaseServer.Access, tableName) + "." + conditions[i].Field.fieldName + ")");
sbSqlHeader.Remove(0, sbSqlHeader.Length);
sbSqlHeader.Append(tempString);
break;
//NOTE: COUNT fields must be after SELECT statement
case CriteriaOperator.Count:
//get the field
fieldName = generator.GetTableName(DatabaseServer.Access, tableName) + "." + conditions[i].Field.fieldName;
//we have the field name now search for it in the fields list
index = sbSqlHeader.ToString().IndexOf(fieldName);
//now remove the field from the list.
if (index == -1)
{
throw new ArgumentException("Invalid count clause");
}
tempString = sbSqlHeader.ToString();
tempString = tempString.Remove(index, fieldName.Length);
//add it at the beginning of the select
tempString = tempString.Insert(SELECT_FIELD_LENGTH, " count(" + generator.GetTableName(DatabaseServer.Access, tableName) + "." + conditions[i].Field.fieldName + ")");
sbSqlHeader.Remove(0, sbSqlHeader.Length);
sbSqlHeader.Append(tempString);
break;
}
}
//last check to prevent invalid sql queries
//conditions remove the "WHERE".
if (sbuild.ToString().EndsWith(" WHERE "))
{
sbuild.Remove(sbuild.Length - WHERE_FIELD_LENGTH, WHERE_FIELD_LENGTH);
}
//check if we have conditions which don't require a "WHERE" clause
if (sbuild.Length == 0 && sbOrderByCriteria.Length > 0)
{
//remove from query header
sbSqlHeader.Remove(sbSqlHeader.Length - WHERE_FIELD_LENGTH, WHERE_FIELD_LENGTH);
}
if (sbOrderByCriteria.Length > 0)
{
sbuild.Append(" " + sbOrderByCriteria);
}
return(sbuild.ToString());
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (listParameterNames != null)
{
listParameterNames.Clear();
listParameterNames = null;
}
}
}
public ModificationCommandBatchFake(DbDataReader reader, ISqlGenerator sqlGenerator = null)
: base(sqlGenerator ?? new FakeSqlGenerator(), new MetadataExtensionProviderFake())
{
_reader = reader;
ShouldAddCommand = true;
ShouldValidateSql = true;
}
public TestModificationCommandBatch(ISqlGenerator sqlGenerator)
: base(sqlGenerator)
{
}
/// <summary>
/// 初始化类<see cref="MigrationsSqlGenerator"/>。
/// </summary>
/// <param name="sql">SQL辅助实例。</param>
protected MigrationsSqlGenerator(ISqlGenerator sql)
{
Sql = sql;
}
public DatabaseAdapter(IDbConnection conn, ISqlGenerator sqlGenerator)
{
this.DbConnection = conn;
this.sqlGenerator = sqlGenerator;
}
/// <summary>
/// 初始化 <see cref="Database"/> 类的新实例。
/// </summary>
/// <param name="factory">日志工厂接口。</param>
/// <param name="options">配置选项。</param>
/// <param name="sqlGenerator">SQL辅助类接口。</param>
public SqlServerDatabase(ILoggerFactory factory, IOptions<DataSourceOptions> options, ISqlGenerator sqlGenerator) : base(factory, SqlClientFactory.Instance, options, sqlGenerator)
{
}
/// <summary>
/// Gets the join type value.
/// </summary>
/// <param name="j">The j.</param>
/// <param name="generator"></param>
/// <returns></returns>
public static string GetJoinTypeValue(ISqlGenerator generator, JoinType j)
{
string result = generator.sqlFragment.INNER_JOIN;
switch(j)
{
case JoinType.Outer:
result = generator.sqlFragment.OUTER_JOIN;
break;
case JoinType.LeftInner:
result = generator.sqlFragment.LEFT_INNER_JOIN;
break;
case JoinType.LeftOuter:
result = generator.sqlFragment.LEFT_OUTER_JOIN;
break;
case JoinType.RightInner:
result = generator.sqlFragment.RIGHT_INNER_JOIN;
break;
case JoinType.RightOuter:
result = generator.sqlFragment.RIGHT_OUTER_JOIN;
break;
case JoinType.Cross:
result = generator.sqlFragment.CROSS_JOIN;
break;
case JoinType.NotEqual:
result = generator.sqlFragment.UNEQUAL_JOIN;
break;
}
return result;
}
public DataRepository(IDbConnection connection, ISqlGenerator <TEntity> sqlGenerator) : base(connection)
{
_sqlGenerator = sqlGenerator;
}
public abstract string GetSql(ISqlGenerator sqlGenerator, IDictionary<string, object> parameters);
/// <summary>
/// 初始化类<see cref="SearchManager"/>。
/// </summary>
/// <param name="model">模型管理接口。</param>
/// <param name="indexes">索引数据库操作接口。</param>
/// <param name="searches">搜索实体数据库操作接口。</param>
/// <param name="generator">SQL生成器。</param>
/// <param name="sqlHelper">SQL辅助接口。</param>
public SearchManager(IModel model, IRepository <SearchIndex> indexes, IRepository <SearchDescriptor> searches, ISqlGenerator generator, ISqlHelper sqlHelper)
{
_model = model;
_indexes = indexes;
_searches = searches;
_generator = generator;
_sqlHelper = sqlHelper;
}
public TestModificationCommandBatchFactory(
ISqlGenerator sqlGenerator)
: base(sqlGenerator)
{
}
//NOTE: Because this is a "Dependency Injection Oriented Package"
//we need to pass the database connection and the SQL Generator as parameters
public DefaultTimeframeRepository(OracleConnection connection,
ISqlGenerator <DefaultTimeframe> sqlGenerator)
: base(connection, sqlGenerator)
{
}
