public IDbQueryExpressionMemberNameParser GetParser(IDbModelStrategy modelStrategy = null)
{
return(new SqlDbQueryGetMemberNameExpressionNode()
{
ModelStrategy = modelStrategy
});
}
public DbQueryStrategyBase(IDbModelStrategy modelStrategy, DbQueryStrategyTypes strategyType, int pageSize = 0) : this()
{
this.ModelStrategy = modelStrategy;
this.StrategyType = strategyType;
this.PageSize = pageSize;
Parse();
}
public DbQueryStrategyBase(IDbModelStrategy modelStrategy, int pageSize = 0) : this()
{
_modelType = modelStrategy.ModelType;
this.PageSize = pageSize;
this.ModelStrategy = modelStrategy;
Parse();
}
public SqlDbSelectAggregateStrategy(
DbQueryAggregateMode aggregateMode,
IDbModelStrategy modelStrategy,
IEnumerable <DbQueryWhereClause <TModel> > filterExpressions = null,
DbQueryColumnClause <TModel> columnExpression = null,
IEnumerable <DbQueryGroupByClause <TModel> > groupBySelector = null) : base(DbQueryStrategyTypes.Select)
{
_modelStrategy = modelStrategy;
_aggregMode = aggregateMode;
_parameterDictionary = new Dictionary <string, object>();
if (filterExpressions != null)
{
_filters = ParseFilters(filterExpressions);
}
if (groupBySelector != null)
{
_groupBySelectors = ParseGroupByColumns(groupBySelector);
}
if (aggregateMode != DbQueryAggregateMode.Any &&
aggregateMode != DbQueryAggregateMode.Count &&
aggregateMode != DbQueryAggregateMode.CountBig)
{
if (_columns == null)
{
_columns = ParseSelectorToColumn(columnExpression);
}
}
}
private static IDbSchemaActionProvider GetSchemaGenerationProvider(
IDbModelStrategy ModelStrategy, IEnumerable <IDbSchemaStrategy> SchemaGenerationStrategies, string ConnectionString)
{
return(App.ServiceProviders.Resolve <IDbSchemaActionProvider>(
new NamedParameter("ModelStrategy", ModelStrategy),
new NamedParameter("SchemaGenerationStrategies", SchemaGenerationStrategies),
new NamedParameter("ConnectionString", ConnectionString)));
}
public SqlDbSelectAggregateStrategy(
DbQueryAggregateMode aggregateMode,
Type modelType,
IDbModelStrategy modelStrategy) : base(modelType)
{
_modelStrategy = modelStrategy;
_aggregMode = aggregateMode;
_parameterDictionary = new Dictionary <string, object>();
}
public SqlDbSelectStrategy(
Type modelType,
IDbModelStrategy modelStrategy,
int pageSize = 0) : base(modelType)
{
_modelStrategy = modelStrategy;
_parameterDictionary = new Dictionary <string, object>();
_enablePaging = pageSize > 0;
_pageIdx = 0;
_pageIdxLast = 0;
_rowCount = 0;
}
public DbSchemaActionProvider(
IDbModelStrategy ModelStrategy,
IEnumerable <IDbSchemaStrategy> SchemaStrategies,
string ConnectionString)
{
ParameterChecker.NotNull(ModelStrategy);
ParameterChecker.NotNull(SchemaStrategies);
ParameterChecker.NotNullOrEmpty(ConnectionString);
this._modelStrategy = ModelStrategy;
this._schemaStrategies = SchemaStrategies;
this._connectionString = ConnectionString;
}
private static bool TryConvertModelStrategy <TModel>(object item, out IDbModelStrategy <TModel> strategy)
where TModel : class, new()
{
strategy = null;
var value = item as IDbModelStrategy <TModel>;
if (value == null)
{
return(false);
}
strategy = value;
return(true);
}
public SqlDbSelectStrategy(
IDbModelStrategy modelStrategy,
long skipCount = 0,
long takeCount = 0,
IEnumerable <DbQueryWhereClause <TModel> > filterExpressions = null,
IEnumerable <DbQueryOrderByClause <TModel> > orderByExpressions = null) : base(DbQueryStrategyTypes.Select)
{
_modelStrategy = modelStrategy;
_parameterDictionary = new Dictionary <string, object>();
if (filterExpressions != null)
{
_filters = ParseFilters(filterExpressions);
}
if (orderByExpressions != null && orderByExpressions.Any())
{
_orderByColumns = ParseOrderByColumns(orderByExpressions);
}
_skipCount = skipCount;
_takeCount = takeCount;
}
public SqlDbUpdateStrategy(IDbModelStrategy modelStrategy) : base(modelStrategy, DbQueryStrategyTypes.Update)
{
}
private static IDbModelStrategy DetectAndConfigureModelStrategy(IDbModelStrategy strategy)
{
var modelType = strategy.ModelType;
var properties = modelType.GetProperties().Where(p => p.DeclaringType != typeof(object));
var attrTable = GetClassLevelDataAnnotation <TableAttribute>(modelType);
if (attrTable != null)
{
strategy.ChangeTableName(attrTable.TableName);
}
foreach (var property in properties)
{
var bindingPropertyInfo = strategy.PropertyStrategies
.FirstOrDefault(
c => c.GetPropertyInfo().PropertyType == property.PropertyType &&
c.GetPropertyInfo().DeclaringType == property.DeclaringType &&
c.GetPropertyInfo().Name == property.Name)
?? strategy.GetPropertyStrategy(property);
// allow null attribute
var attrAllowNull = GetPropertyLevelDataAnnotation <AllowNullAttribute>(property);
if (attrAllowNull != null && attrAllowNull.AllowNull)
{
bindingPropertyInfo = bindingPropertyInfo.AllowNull();
}
// detect nullable type.
if (property.PropertyType.IsNullable())
{
bindingPropertyInfo.AllowNull();
}
// key attribute
var attrKey = GetPropertyLevelDataAnnotation <KeyAttribute>(property);
if (attrKey != null)
{
if (bindingPropertyInfo.IsAllowNull())
{
throw new DbKeyNotAllowNullException();
}
bindingPropertyInfo = bindingPropertyInfo.AsKey();
}
// ignore attribute.
var ignoreKey = GetPropertyLevelDataAnnotation <IgnoreAttribute>(property);
if (ignoreKey != null)
{
bindingPropertyInfo.IgnoreProperty(ignoreKey.IgnoreKinds);
}
// DbType attrubyte
var attrDbType = GetPropertyLevelDataAnnotation <DbTypeAttribute>(property);
if (attrDbType != null)
{
bindingPropertyInfo = bindingPropertyInfo.MapDbType(attrDbType.DbType);
}
if (property.PropertyType == typeof(int) ||
property.PropertyType == typeof(long) ||
property.PropertyType == typeof(short) ||
property.PropertyType == typeof(uint) ||
property.PropertyType == typeof(ulong) ||
property.PropertyType == typeof(ushort))
{
var attrAutoIncremental =
GetPropertyLevelDataAnnotation <AutoIncrementalAttribute>(property);
if (attrAutoIncremental != null)
{
bindingPropertyInfo = bindingPropertyInfo.AsIncremental();
}
}
// autogenerate attribute.
if (property.PropertyType != typeof(Guid) && property.PropertyType != typeof(DateTime) &&
property.PropertyType != typeof(int) && property.PropertyType != typeof(long) &&
property.PropertyType != typeof(short) && property.PropertyType != typeof(uint) &&
property.PropertyType != typeof(ulong) && property.PropertyType != typeof(ushort) &&
bindingPropertyInfo.GetMapDbType() != DbType.Guid &&
bindingPropertyInfo.GetMapDbType() != DbType.DateTime &&
bindingPropertyInfo.GetMapDbType() != DbType.Int16 &&
bindingPropertyInfo.GetMapDbType() != DbType.Int32 &&
bindingPropertyInfo.GetMapDbType() != DbType.Int64 &&
bindingPropertyInfo.GetMapDbType() != DbType.UInt16 &&
bindingPropertyInfo.GetMapDbType() != DbType.UInt32 &&
bindingPropertyInfo.GetMapDbType() != DbType.UInt64)
{
continue;
}
var attrAutoGenerated =
GetPropertyLevelDataAnnotation <AutoGeneratedAttribute>(property);
if (attrAutoGenerated == null)
{
continue;
}
if (attrAutoGenerated.AtInsert)
{
bindingPropertyInfo = bindingPropertyInfo.AsAutoGenerated();
}
if (attrAutoGenerated.AtUpdate)
{
bindingPropertyInfo.AsAutoGeneratedAtUpdate();
}
}
return(strategy);
}
public IDbSchemaStrategy GetCreateTableStrategy(IDbModelStrategy modelStrategy)
{
return(new SqlDbSchemaCreateTableStrategy(modelStrategy));
}
public IDbQueryStrategy GetDeleteAllStrategy(IDbModelStrategy modelStrategy)
{
return(new SqlDbDeleteAllStrategy(modelStrategy));
}
public IDbSchemaStrategy GetAlterTableStrategy(IDbModelStrategy modelStrategy)
{
return(new SqlDbSchemaAlterTableStrategy(modelStrategy));
}
public SqlDbDeleteAllStrategy(IDbModelStrategy modelStrategy) : base(modelStrategy)
{
}
public DbTable(IDbModelStrategy modelStrategy, IDbServiceProvider dbServiceProvider) : this()
{
ModelStrategy = modelStrategy;
_serviceProvider = dbServiceProvider;
}
public SqlDbInsertStrategy(IDbModelStrategy modelStrategy) : base(modelStrategy, DbQueryStrategyTypes.Insert)
{
}
public IDbQueryStrategy GetUpdateStrategy <TModel>(IDbModelStrategy modelStrategy) where TModel : class, new()
{
return(new SqlDbUpdateStrategy <TModel>(modelStrategy));
}
public SqlDbSchemaDropTableStrategy(IDbModelStrategy modelStrategy)
{
ParameterChecker.NotNull(modelStrategy);
this.ModelStrategy = modelStrategy;
}
public IDbSchemaStrategy GetDropTableStrategy(IDbModelStrategy modelStrategy)
{
return(new SqlDbSchemaDropTableStrategy(modelStrategy));
}
public SqlDbEmptyStrategy(IDbModelStrategy modelStrategy) : base(modelStrategy)
{
}
public SqlDbInsertStrategy(IDbModelStrategy modelStrategy)
: base(modelStrategy)
{
}
public SqlDbUpdateStrategy(IDbModelStrategy modelStrategy) : base(modelStrategy)
{
}
public IDbQueryStrategy GetSelectAggregationStrategy(DbQueryAggregateMode mode, Type modelType, IDbModelStrategy modelStrategy)
{
return(new SqlDbSelectAggregateStrategy(mode, modelType, modelStrategy));
}
public static IDbQueryExpressionNode GetNodeParser(Expression expression, IDbModelStrategy modelStrategy)
{
SqlDbQueryExpressionNode expressionNode = null;
switch (expression.NodeType)
{
case ExpressionType.NotEqual:
expressionNode = new SqlDbQueryNotEqualExpressionNode();
break;
case ExpressionType.Not:
expressionNode = new SqlDbQueryNotExpressionNode();
break;
case ExpressionType.Equal:
expressionNode = new SqlDbQueryEqualExpressionNode();
break;
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
expressionNode = new SqlDbQueryGreaterThanExpressionNode();
break;
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
expressionNode = new SqlDbQueryLessThanExpressionNode();
break;
case ExpressionType.Add:
case ExpressionType.AddChecked:
expressionNode = new SqlDbQueryAddExpressionNode();
break;
case ExpressionType.Subtract:
case ExpressionType.SubtractChecked:
expressionNode = new SqlDbQuerySubstractExpressionNode();
break;
case ExpressionType.Multiply:
case ExpressionType.MultiplyChecked:
expressionNode = new SqlDbQueryMultiplyExpressionNode();
break;
case ExpressionType.Divide:
expressionNode = new SqlDbQueryDivideExpressionNode();
break;
case ExpressionType.MemberAccess:
expressionNode = new SqlDbQueryMemberAccessExpressionNode();
break;
case ExpressionType.AndAlso:
expressionNode = new SqlDbQueryAndAlsoExpressionNode();
break;
case ExpressionType.OrElse:
expressionNode = new SqlDbQueryOrElseExpressionNode();
break;
case ExpressionType.Constant:
expressionNode = new SqlDbQueryConstantExpressionNode();
break;
case ExpressionType.Call:
expressionNode = new SqlDbQueryCallExpressionNode();
break;
case ExpressionType.Parameter:
expressionNode = new SqlDbQueryParameterExpressionNode();
break;
case ExpressionType.Convert:
expressionNode = new SqlDbQueryConvertExpressionNode();
break;
default:
throw new NotSupportedException("ERROR_GIVEN_QUERY_EXPRESSION_TYPE_NOT_SUPPORTED");
}
expressionNode.ModelStrategy = modelStrategy;
return(expressionNode);
}
public IDbQueryStrategy GetEmptyStrategy(IDbModelStrategy modelStrategy)
{
return(new SqlDbEmptyStrategy(modelStrategy));
}
public string Parse(IDictionary <string, object> parameterDictionary, Expression expressionNode, IDbModelStrategy modelStrategy)
{
var queryNode = SqlDbQueryExpressionFactory.GetNodeParser(expressionNode, modelStrategy);
if (queryNode == null)
{
throw new NotSupportedException("ERROR_NODE_TYPE_NOT_SUPPORTED");
}
return(queryNode.Parse(parameterDictionary, expressionNode));
}
public IDbQueryStrategy GetUpdateStrategy(Type modelType, IDbModelStrategy modelStrategy)
{
return(new SqlDbUpdateStrategy(modelStrategy));
}
public IDbSchemaStrategy GetLookupSchemaExistsStrategy(IDbModelStrategy modelStrategy)
{
return(new SqlDbSchemaLookupSchemaExistsStrategy(modelStrategy));
}
