public string GetCalculatedColumnFieldName(string fieldName, bool useDateStats, bool dontAggregate = false, bool useFieldAlias = false)
{
using (new DebugTimer("CalculatedColumnHelper.GetCalculatedColumnFieldName"))
{
string originalFieldName = fieldName;
fieldName = originalFieldName;
if (!QueryHelpers.IsCalculatedColumnCompiled(fieldName))
{
fieldName = new SqlExpressionParser().ConvertToSql(fieldName);
}
fieldName = ExpandCalculatedColumn(new Stack <string>(), fieldName, useFieldAlias);
var columnsInCalculation = FindColumnsInCalculatedField(fieldName);
var statsTable = GetStatsTable(useDateStats);
//fieldName = FixCalculatedFieldNameToUseActualFieldNames(fieldName, statsTable, ref columnsInCalculation, useFieldAlias);
Dictionary <string, string> tempFieldNameLookups;
fieldName = FixCalculatedFieldNameToUseTemporaryFieldNames(fieldName, statsTable, ref columnsInCalculation, out tempFieldNameLookups, useFieldAlias);
if (!QueryHelpers.IsCalculatedColumnCompiled(fieldName))
{
fieldName = new SqlExpressionParser().ConvertToSql(fieldName);
}
var shouldAggregate = !dontAggregate && fieldName.Contains(' ');
foreach (var foundColumn in columnsInCalculation)
{
var aggregate = QueryHelpers.GetAggregate(foundColumn.Key.FieldAggregationMethod);
string replaceColumnName = tempFieldNameLookups[foundColumn.Value];
if (shouldAggregate)
{
replaceColumnName = GenerateAggregateColumnSql(aggregate, replaceColumnName);
}
fieldName = ReplaceFieldName(new Stack <string>(), fieldName, foundColumn.Value, replaceColumnName);
}
return(fieldName);
}
}
public virtual bool FieldNameIsValid(string fieldName)
{
try
{
if (!QueryHelpers.IsCalculatedColumnCompiled(fieldName))
{
var result = new SqlExpressionParser().ConvertToSql(fieldName);
}
if (SqlInjectionChecker.HasInjection(fieldName))
{
return(false);
}
}
catch
{
return(false);
}
return(true);
}
public IDbQueryFetchable <TSelect> Select <TSelect>(Expression <Func <T, TSelect> > fields)
{
var pp = SqlExpressionParser.Parse(fields.Body, this);
throw new NotImplementedException();
}
/// <summary>
/// Finds nested calculated columns in a fieldname and replaces the referenced calculated column with the full formula
/// </summary>
/// <param name="fieldName"></param>
/// <returns></returns>
public string ExpandCalculatedColumn(Stack <string> existingFieldNames, string fieldName, bool useFieldAlias = false)
{
var result = fieldName;
int recursions = 3;
while (recursions > 0) // needed for synonym columns
{
recursions--;
var foundColumns = FindColumnsInCalculatedField(result, throwOnNoMatch: false);
if (!foundColumns.Any(x => x.Key.IsCalculated))
{
break;
}
var calculatedColumns = new List <KeyValuePair <ReportColumnMapping, string> >();
// either the fieldname has a formula
// or the field name is a reference to another field
foreach (var found in foundColumns)
{
if (found.Key.IsCalculated)
{
if (existingFieldNames.Contains(fieldName))
{
throw new ArgumentException("Recursion detected on field " + fieldName, "fieldName");
}
existingFieldNames.Push(fieldName);
string newFieldName = found.Key.FieldName;
if (useFieldAlias && found.Key.FieldAggregationMethod != FieldAggregationMethod.Average)
{
newFieldName = GetFieldAlias(found.Key);
}
else
{
var nestedColumns = FindColumnsInCalculatedField(found.Value, throwOnNoMatch: false);
if (nestedColumns.Any())
{
if (nestedColumns.Count > 1)
{
calculatedColumns.Add(found);
}
else if (nestedColumns.First().Key.IsCalculated)
{
calculatedColumns.Add(found);
}
}
}
if (QueryHelpers.IsCalculatedColumn(newFieldName) && !QueryHelpers.IsCalculatedColumnCompiled(newFieldName))
{
newFieldName = new SqlExpressionParser().ConvertToSql(newFieldName);
}
result = ReplaceFieldName(existingFieldNames, result, found.Value, newFieldName);
existingFieldNames.Pop();
}
}
}
return(result);
}
public void GetClosingBracketIndex_WithCase_ReturnsExpected(string input, int openingIndex, int expected)
{
var result = new SqlExpressionParser().GetClosingBracketIndex(input, openingIndex);
Assert.AreEqual(expected, result);
}
