/// <summary> /// Returns SQL statement for the FromClause member of the SelectClause /// </summary> /// <param name="selectClause"></param> /// <returns></returns> private string FromSql(IConnectorFormatter formatter, SelectStatement selectClause, List <FromAlias> list) { var fromClause = selectClause.FromClause; var sql = "from " + BuildJoins(formatter, fromClause, list); return(sql); }
public SelectExpressionAnalyzer(IConnectorFormatter formatter, LambdaExpression expression, List <FromAlias> aliasList) { this._aliasList = aliasList; _formatter = formatter; _parameters = expression.Parameters; _expression = expression; _memberAccessDecoder = new MemberAccessDecoder(_parameters.ToList(), _aliasList); }
/// <summary> /// /// </summary> /// <param name="from"></param> /// <returns></returns> private string TableSql(IConnectorFormatter formatter, FromClause from, List <FromAlias> aliases) { //get alias for this clause var alias = aliases.First(x => x.FromClause == from); if (from.SubSelect != null) { return("(" + alias.SubGeneratedSelect.Sql + ") " + alias.Name); } return(formatter.TableNameEscape(from.SchemaName, from.TableName) + " " + alias.Name); }
public object CreateInstance(IVirtualDataReader reader, IConnectorFormatter formatter) { //set contructor arguments for (var i = 0; i < ConstArgumentsBuffer.Length; i++) { var argumentAlias = ArgumentMapping[i]; var resultObject = formatter.FormatFrom(reader[argumentAlias.Alias]); if (resultObject is DBNull) { ConstArgumentsBuffer[i] = null; } else { ConstArgumentsBuffer[i] = resultObject; } } //create instance var instance = Constructor.Invoke(ConstArgumentsBuffer); //set properties on an instance for (var i = 0; i < MemberMapping.Count; i++) { var tuple = MemberMapping[i]; var property = tuple.Item3 as PropertyInfo; var v = reader[tuple.Item1]; // null values are skipped // property vlues will be set to their defaults if (v == DBNull.Value) { continue; } //set field var field = tuple.Item3 as FieldInfo; if (field != null) { SetValue(instance, field, formatter.FormatFrom(field.FieldType, v)); } //set property only if set method is available if (property != null && property.SetMethod != null) { SetValue(instance, property, formatter.FormatFrom(property.PropertyType, v)); } } return(instance); }
/// <summary> /// Initializes a new instance of the <see cref="T:Ceql.Statements.UpdateStatement`1"/> class. /// </summary> /// <param name="expressions">Expressions.</param> public UpdateStatement(params Expression <SelectExpression <T, object> >[] expressions) { _formatter = CeqlConfiguration.Instance.GetConnectorFormatter(); _fromClause = new FromClause <T>(); _primaryKeyProperties = typeof(T).GetPrimaryKeyProperties(); _fromAlias = StatementGenerator.GetAliasList(_fromClause); foreach (var expression in expressions) { var selectList = (List <SelectAlias>) new SelectExpressionAnalyzer(_formatter, expression, _fromAlias).Sql(); _selections.AddRange(selectList); } }
public SelectExpressionAnalyzer(IConnectorFormatter formatter, SelectStatement select, List <FromAlias> aliasList) { this._aliasList = aliasList; this._select = select; _formatter = formatter; var lambda = select.SelectExpression as LambdaExpression; if (lambda == null) { throw new Exception("Invalid expression"); } _parameters = lambda.Parameters; _expression = lambda; _memberAccessDecoder = new MemberAccessDecoder(_parameters.ToList(), _aliasList); }
private static ExpressionSql HandleExpression <T>(WhereClause <T> statement, IConnectorFormatter formatter) { if (statement == null) { return(null); } var aliasList = StatementGenerator.GetAliasList(statement.FromClause); var fromSql = StatementGenerator.FromSql(statement.FromClause, aliasList, formatter); var whereSql = StatementGenerator.WhereSql(statement, aliasList, formatter); return(new ExpressionSql { WhereSql = whereSql, FromSql = fromSql }); }
/// <summary> /// Private constructor /// </summary> protected SelectStatementGenerator(IConnectorFormatter formatter) { _formatter = formatter; }
/// <summary> /// /// </summary> /// <param name="from"></param> /// <param name="aliasList"></param> /// <returns></returns> protected string BuildJoins(IConnectorFormatter formatter, FromClause from, List <FromAlias> aliasList) { var alias = aliasList.First(x => x.FromClause == from); var joinType = " join "; switch (from.JoinType) { case EJoinType.Inner: joinType = " join "; break; case EJoinType.Left: joinType = " left join "; break; case EJoinType.Right: joinType = " right join "; break; default: joinType = " join "; break; } //joined tables if (from.Parent != null) { var analyzer = new ConditionExpressionAnalyzer(_formatter); var statement = BuildJoins(formatter, from.Parent, aliasList) + joinType + TableSql(formatter, from, aliasList) + " on "; var joinCondition = ""; for (var i = 0; i < from.JoinExpression.Count; i++) { var j = from.JoinExpression[i]; var faList = FilterExpressionAliasList(aliasList, j.ExpressionBoundClauses); if (i >= 1) //dont care about operator if it is a first join expression { switch (j.Operator) { case EBooleanOperator.And: joinCondition += " and "; break; case EBooleanOperator.Or: joinCondition += " or "; break; case null: break; default: break; } } joinCondition += analyzer.Sql(faList, j.Expression); } //append join condition statement += joinCondition; return(statement); } //driver tables return(TableSql(formatter, from, aliasList)); }
public DeleteStatementModel(IConnectorFormatter formatter) : base(formatter) { }
public InsertStatementModel(IConnectorFormatter formatter) : base(formatter) { }
public SelectEnumerator(SelectClause <TResult> selectClause, IConnectorFormatter formatter) { var rowLambda = selectClause.SelectExpression as LambdaExpression; var compiledRowLambda = rowLambda.Compile(); var paramInfo = new List <ParameterResultInfo>(); _formatter = formatter; var generatedSelect = selectClause.Model; _selectList = generatedSelect.SelectList; foreach (var x in rowLambda.Parameters) { //look for the type in the select list var sel = _selectList.FirstOrDefault(s => s.SourceType == x.Type); if (sel == null) { paramInfo.Add(null); continue; } paramInfo.Add(new ParameterResultInfo() { Type = x.Type, ArgumentMapping = ConstructorArgumentsMap(x.Type), MemberMapping = PropertyMapping(x.Type), Constructor = x.Type.GetConstructors()[0], ConstArgumentsBuffer = new object[x.Type.GetConstructors()[0].GetParameters().Length] }); } var connection = VirtualDataSource.GetConnection(); _result = new List <TResult>(); connection.Run(selectClause, (reader) => { /* * for each row: * for each parameter * 1. instantiate parameter * 2. set property values * 3. execute lambda expression * 4. cast to result */ var arguments = new object[paramInfo.Count]; for (var i = 0; i < paramInfo.Count; i++) { var p = paramInfo[i]; if (p != null) { arguments[i] = p.CreateInstance(reader, _formatter); } } _result.Add((TResult)compiledRowLambda.DynamicInvoke(arguments)); }); listEnumerator = _result.GetEnumerator(); }
/// <summary> /// Returns sql for the 'WHERE' clause of the sql query /// </summary> /// <returns>The sql.</returns> /// <param name="whereClause">Where clause.</param> /// <param name="aliasList">Alias list.</param> /// <param name="formatter">Formatter.</param> public static string WhereSql(WhereClause whereClause, List <FromAlias> aliasList, IConnectorFormatter formatter) { //var whereClause = selectClause.WhereClause; var analyzer = new ConditionExpressionAnalyzer(formatter); var whereSql = "WHERE "; for (var i = 0; i < whereClause.FilterExpression.Count; i++) { var filter = whereClause.FilterExpression[i]; if (i >= 1) //dont care about operator if it is a first join expression { switch (filter.Operator) { case EBooleanOperator.And: whereSql += " and "; break; case EBooleanOperator.Or: whereSql += " or "; break; case null: break; default: break; } } whereSql += analyzer.Sql(FilterExpressionAliasList(aliasList, filter.ExpressionBoundClauses), filter.Expression); } return(whereSql); }
/// <summary> /// Returns sql for the 'FROM' clause of the sql query /// </summary> /// <returns>The sql.</returns> /// <param name="fromClause">From clause.</param> /// <param name="list">List.</param> /// <param name="formatter">Formatter.</param> public static string FromSql(FromClause fromClause, List <FromAlias> list, IConnectorFormatter formatter) { var sql = "FROM " + BuildJoins(formatter, fromClause, list); return(sql); }
public StatementModel(IConnectorFormatter formatter) { Formatter = formatter; }
public ConditionExpressionAnalyzer(IConnectorFormatter formatter) { _formatter = formatter; }