/// <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;
}
