/// <summary> /// Perform each function that is applicable in the current gate context. The input parameter /// is passed to the first applicable function, and the result of that function is used as the input /// for the next applicable function, etc. This allows for chaining multiple functions, each having /// an opportunity to modify the input. /// </summary> /// <param name="context">gate context</param> /// <param name="input">the input object</param> /// <param name="mode">mode to run the gated code in</param> /// <param name="functions">array of gated functions</param> /// <typeparam name="T">the return type of the function</typeparam> /// <returns>instance of T (default if no applicable action found)</returns> public static T PerformEachFunction <T>(this IGateContext context, GatedCode.Modes mode, T input, params GatedFunc <T, T>[] functions) { Array.ForEach(functions, (function) => { input = SelectFunction(context, mode, function)(input); } ); return(input); }
public string AddHaving(string tableName, string fieldName, SelectFunction selectFunction, string opr, string parameter) { var func = selectFunction.ToString(); _componentList.Add(string.Format("{2}({0}.{1}) {3} {4}", tableName, fieldName, func, opr, _adapter.Parameter(parameter))); return(parameter); }
public void HavingWithCount <T>(Expression <Func <T, object> > expression, SelectFunction selectFunction, Expression <Func <int, bool> > cmp) { var fieldName = GetColumnName(GetMemberExpression(expression.Body)); var tmpcmp = GetBinaryExpression(cmp.Body); var opr = _operationDictionary[tmpcmp.NodeType]; var value = GetExpressionValue(tmpcmp.Right); _builder.Having(GetTableName <T>(), fieldName, selectFunction, opr, value); }
internal void Aggregate(LambdaExpression expression, SelectFunction selectFunction) { expression.ThrowIfNull(nameof(expression)); var fieldName = TableInfo.GetColumnName(expression.Body.GetMemberExpression()); var memberNode = new MemberNode { TableName = TableName, FieldName = fieldName }; var selectionString = SqlFormatter.SelectAggregate(memberNode, selectFunction.ToString()); Context.Selection.Add(selectionString); }
public void Select(string tableName, string fieldName, string alias, SelectFunction selectFunction) { if (string.IsNullOrEmpty(alias) || fieldName == alias) { Select(tableName, fieldName, selectFunction); } else { var selectionString = $"{selectFunction}({Adapter.Field(tableName, fieldName)}) {Adapter.Alias(alias)}"; SelectionList.Add(selectionString); } }
public void Select(string tableName, string fieldName, SelectFunction selectFunction, string alias = null) { string selectionString = null; if (string.IsNullOrEmpty(alias)) { selectionString = string.Format("{0}({1})", selectFunction.ToString(), Adapter.Field(tableName, fieldName)); } else { selectionString = string.Format("{0}({1}) AS {2}", selectFunction.ToString(), Adapter.Field(tableName, fieldName), alias); } _selectionList.Add(selectionString); }
public void Select(string tableName, string fieldName, SelectFunction selectFunction, string aliasName) { string name = string.IsNullOrEmpty(aliasName) ? fieldName : aliasName; name = _adapter.Field(name); var fname = fieldName; if (fieldName != "*") { fname = _adapter.Field(tableName, fieldName); } var selectionString = string.Format("{0}({1}) AS {2}", selectFunction.ToString(), fname, name); _selectionList.Add(selectionString); }
internal void Select(string tableName, string columnName, SelectFunction selectFunction, string tableAlias, string columnAlias) { var functionNoHasColumnName = !String.IsNullOrEmpty(columnName); var functionName = selectFunction.ToString(); var existsAlias = !String.IsNullOrEmpty(columnAlias); var tableNameToUse = String.IsNullOrEmpty(tableAlias) ? tableName : tableAlias; var columnNameToUserFunction = functionNoHasColumnName ? _sqlAdapter.GetColumnName(tableNameToUse, columnName) : "1"; var functionClause = new StringBuilder($"{functionName.ToUpper()}({columnNameToUserFunction}) "); if (existsAlias) { functionClause.Append($"AS {columnAlias} "); } _sqlQueryBuilderExtension.AddFunctionsName(functionClause.ToString()); }
private void AddHavingClause(ClauseInput clauseInput, SelectFunction selectFunction) { var havingEpression = $"{selectFunction.ToString().ToUpper()}({clauseInput.Column}) {clauseInput.Operation} {clauseInput.ParameterFormated}"; _havingClause.Add(havingEpression); }
public void Having(string tableName, string fieldName, SelectFunction selectFunction, string opr, object value) { var paramId = _havingBuilder.AddHaving(tableName, fieldName, selectFunction, opr, NextParamId()); AddParameter(paramId, value); }
/// <summary> /// Method to add 'HAVING' function in select. /// </summary> /// <typeparam name="THaving">Indicates a new type to use for table columns.</typeparam> /// <param name="conditionsExp">Indicates column to use in the 'HAVING' clause, through expression.</param> /// <param name="tableAlias">Use this parameter when it is necessary to reference the table by alias.</param> /// <returns>Returns the instance of FluentSqlBuilder<TTable>. Corresponds to the root instance.</returns> public FluentSqlBuilder <TTable> Having <THaving>(SelectFunction selectFunction, Expression <Func <THaving, bool> > conditionsExp, string tableAlias = null) { _resolver.AddHaving(tableAlias, conditionsExp, TargetClauseType.Having, selectFunction); return(this); }
public void AddHaving <TTable>(string tableAlias, Expression <Func <TTable, bool> > expressionFilter, TargetClauseType targetClauseType, SelectFunction selectFunction) { var expressionTree = GetExpressionTree(expressionFilter); _lambdaResolverExtension.BuildSelect(expressionTree, tableAlias, targetClauseType, selectFunction); }
public void SelectWithFunction <T>(Expression <Func <T, object> > expression, SelectFunction selectFunction) { SelectWithFunction <T>(expression.Body, selectFunction); }
private void SelectWithFunction <T>(Expression expression, SelectFunction selectFunction) { var fieldName = GetColumnName(GetMemberExpression(expression)); Builder.Select(GetTableName <T>(), fieldName, selectFunction); }
/// <summary> /// Perform a function that is applicable in the current gate context /// </summary> /// <param name="context">gate context</param> /// <param name="mode">mode to run the gated code in</param> /// <param name="functions">array of gated functions</param> /// <typeparam name="T">the return type of the function</typeparam> /// <returns>instance of T (default if no applicable action found)</returns> public static Task <T> PerformFunction <T>(this IGateContext context, GatedCode.Modes mode, params GatedAsyncFunc <T>[] functions) => SelectFunction(context, mode, null, functions)();
/// <summary> /// Perform a function that is applicable in the current gate context /// </summary> /// <param name="context">gate context</param> /// <param name="functions">array of gated functions</param> /// <typeparam name="T">the return type of the function</typeparam> /// <returns>instance of T (default if no applicable action found)</returns> public static Task <T> PerformFunction <T>(this IGateContext context, params GatedAsyncFunc <T>[] functions) => SelectFunction(context, functions)();
/// <summary> /// Perform a function that is applicable in the current gate context /// </summary> /// <typeparam name="T">the return type of the function</typeparam> /// <param name="context">gate context</param> /// <param name="gate">target gate</param> /// <param name="function">function delegate</param> /// <returns>instance of T (default if no applicable action found)</returns> public static Task <T> PerformFunction <T>(this IGateContext context, IGate gate, Func <Task <T> > function) => SelectFunction(context, new GatedAsyncFunc <T>(gate, function))();
/// <summary> /// Perform a function that is applicable in the current gate context /// </summary> /// <typeparam name="T">the return type of the function</typeparam> /// <param name="context">gate context</param> /// <param name="gate">target gate</param> /// <param name="function">function delegate</param> /// <returns>instance of T (default if no applicable action found)</returns> public static T PerformFunction <T>(this IGateContext context, IGate gate, Func <T> function) => SelectFunction(context, new GatedFunc <T>[] { new GatedFunc <T>(gate, function) })();
public void Select(SelectFunction selectFunction, string fieldName) { var selectionString = string.Format("{0}({1})", selectFunction.ToString(), fieldName); _selectionList.Add(selectionString); }
public void Select(string tableName, string fieldName, SelectFunction selectFunction) { var selectionString = string.Format("{0}({1})", selectFunction.ToString(), Adapter.Field(tableName, fieldName)); _selectionList.Add(selectionString); }
public void SelectWithFunction <T>(Expression <Func <T, object> > expression, SelectFunction selectFunction, string aliasName, string tableAlias) { var fieldName = "*"; if (expression != null) { fieldName = GetColumnName(GetMemberExpression(expression.Body)); } _builder.Select(tableAlias, fieldName, selectFunction, aliasName); }
public void SelectWithFunctionSubQuery <T, TMain>(Expression <Func <T, object> > expression, SelectFunction selectFunction, Expression <Func <TMain, object> > aliasProp, string subAlias) { var fieldName = "*"; if (expression != null) { fieldName = GetColumnName(GetMemberExpression(expression.Body)); } var aliasFieldName = ""; if (aliasProp != null) { aliasFieldName = GetColumnName(GetMemberExpression <TMain>(aliasProp.Body)); } _builder.Select(subAlias, fieldName, selectFunction, aliasFieldName); }
internal void SelectWithFunction <TTable>(Expression <Func <TTable, object> > expression, SelectFunction selectFunction, string tableAlias, string columnAlias) { _lambdaResolverExtension.SelectWithFunction <TTable>(expression.Body, selectFunction, tableAlias, columnAlias); }
public void SelectWithFunction <T>(SelectFunction selectFunction) { Builder.Select(selectFunction); }
internal void SelectWithFunctionWithoutColumn <TTable>(SelectFunction selectFunction, string tableAlias, string columnAlias) { var tableName = SqlBuilderFluentHelper.GetTableName <TTable>(); _sqlQueryBuilder.Select(tableName, null, selectFunction, tableAlias, columnAlias); }
public void Select(string tableName, string fieldName, SelectFunction selectFunction) { var selectionString = $"{selectFunction}({Adapter.Field(tableName, fieldName)})"; SelectionList.Add(selectionString); }
public void SelectWithFunction <T>(SelectFunction selectFunction, string fieldName = "*") { _builder.Select(selectFunction, fieldName); }
public void Select(SelectFunction selectFunction) { var selectionString = $"{selectFunction}(*)"; SelectionList.Add(selectionString); }
public void SelectWithFunctionSubQuery <T>(Expression <Func <T, object> > expression, SelectFunction selectFunction, string subAlias) { var fieldName = "*"; if (expression != null) { fieldName = GetColumnName(GetMemberExpression(expression.Body)); } _builder.Select(subAlias, fieldName, selectFunction, ""); }
public void Select(string tableName, string fieldName, SelectFunction selectFunction) { var selectionString = string.Format("{0}({1})", selectFunction.ToString(), Adapter.Field(tableName, fieldName)); _selectionList.Add(selectionString); }
/// <summary> /// Perform a function that is applicable in the current gate context based on the passed predicate. /// </summary> /// <typeparam name="T">Generic type.</typeparam> /// <param name="context">The context.</param> /// <param name="conditionalPredicate">The conditional predicate.</param> /// <param name="functions">The functions.</param> /// <returns>Func to perform, (default if no applicable action found)</returns> public static T PerformConditionalFunction <T>(this IGateContext context, Func <bool> conditionalPredicate, params GatedFunc <T>[] functions) => SelectFunction(context, GatedCode.Modes.Scoped, conditionalPredicate, functions)();