private string ParseSelectorToColumn(DbQueryColumnClause <TModel> expression)
{
var exp = expression.ColumExpression;
// check expression type is "New Expression" or "Parameter Expression"
if (exp.Body is NewExpression)
{
var newExpNode = new SqlDbQueryNewExpressionRenderColumnsNode();
newExpNode.ModelStrategy = _modelStrategy;
return(newExpNode.Parse(_parameterDictionary, exp.Body));
}
if (exp.Body is UnaryExpression)
{
var paramNode = SqlDbQueryExpressionFactory.GetNodeParser(exp.Body, _modelStrategy);
return(paramNode.Parse(_parameterDictionary, exp.Body));
}
if (exp.Body is ParameterExpression)
{
var paramNode = new SqlDbQueryParameterExpressionRenderColumnsNode();
paramNode.ModelStrategy = _modelStrategy;
return(paramNode.Parse(_parameterDictionary, exp.Body));
}
throw new NotSupportedException("Not supported expression type.");
}
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 object GetDbQueryAggregationValue(
DbQueryAggregateMode queryMode,
Expression <Func <TModel, object> > columnSpecifier,
Expression <Func <TModel, object> > conditionExpression = null)
{
if (queryMode != DbQueryAggregateMode.Any &&
queryMode != DbQueryAggregateMode.Count &&
queryMode != DbQueryAggregateMode.CountBig)
{
ParameterChecker.NotNull(columnSpecifier);
}
IDbQueryStrategy strategy;
var filterExpressions = new List <DbQueryWhereClause <TModel> >();
if (conditionExpression != null)
{
filterExpressions.Add(new DbQueryWhereClause <TModel>()
{
Clause = conditionExpression,
Operator = DbQueryConditionOperators.And
});
}
if (columnSpecifier == null)
{
strategy = _queryStrategyProvider.GetSelectAggregationStrategy(
_queryTable.ModelStrategy,
queryMode,
(filterExpressions.Any()) ? filterExpressions : _whereClauses
);
}
else
{
var columnExpression = new DbQueryColumnClause <TModel>()
{
ColumExpression = columnSpecifier
};
strategy = _queryStrategyProvider.GetSelectAggregationStrategy(
_queryTable.ModelStrategy,
queryMode,
(filterExpressions.Any()) ? filterExpressions : _whereClauses,
columnExpression
);
}
var sql = strategy.GetDbQueryScript();
var dbparams = strategy.GetDbParameters();
_serviceProvider.Open();
object value;
try
{
value = _serviceProvider.QueryGetScalar(sql, dbparams);
}
catch (Exception exception)
{
throw new DbOperationException("ERROR_SQL_EXECUTION_FAILED", exception, sql, dbparams);
}
finally
{
_serviceProvider.Close();
}
return(value);
}
public IDbQueryStrategy GetSelectAggregationStrategy <TModel>(IDbModelStrategy modelStrategy, DbQueryAggregateMode mode, IEnumerable <DbQueryWhereClause <TModel> > dataFilterOperators = null, DbQueryColumnClause <TModel> columnSpecifier = null, IEnumerable <DbQueryGroupByClause <TModel> > groupBySelector = null) where TModel : class, new()
{
return(new SqlDbSelectAggregateStrategy <TModel>(mode, modelStrategy, dataFilterOperators, columnSpecifier, groupBySelector));
}
