public void IsNullNestedExtension()
{
IQueryableColumn column = Customer.Columns.CustomerId.Max().IsNull(0);
Assert.IsNotNull(column);
Assert.AreEqual("ISNULL(MAX(CustomerID), 0)", string.Format(column.ColumnFormat, column.Name));
}
public void IsNullStaticMethod()
{
IQueryableColumn column = Customer.Columns.CustomerId.IsNull(0);
Assert.IsNotNull(column);
Assert.AreEqual("ISNULL(CustomerID, 0)", string.Format(column.ColumnFormat, column.Name));
}
internal OrderBy(IQueryableColumn column, OrderByDirection direction)
{
Argument.Assert.IsNotNull(column, nameof(column));
Column = column;
Direction = direction;
}
public void SingleAggregateStaticMethod()
{
IQueryableColumn column = Customer.Columns.CustomerId.Count();
Assert.IsNotNull(column);
Assert.AreEqual("COUNT(CustomerID)", string.Format(column.ColumnFormat, column.Name));
}
public void DoubleAggregateExtension()
{
IQueryableColumn column = Customer.Columns.CustomerId.Count().Max();
Assert.IsNotNull(column);
Assert.AreEqual("MAX(COUNT(CustomerID))", string.Format(column.ColumnFormat, column.Name));
}
public EntitySet <T> Select(IQueryableColumn column1, IQueryableColumn column2)
{
Select(column1);
Select(column2);
return(this);
}
/// <summary>
/// Adds a group by clause on the specified <paramref name="column"/>.
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
public EntitySet <T> GroupBy(IQueryableColumn column)
{
Argument.Assert.IsNotNull(column, Argument.Names.column);
QueryTree.GroupBys.Add(column);
return(this);
}
public EntitySet <T> OrderBy(IQueryableColumn column, OrderByDirection direction)
{
Argument.Assert.IsNotNull(column, Argument.Names.column);
QueryTree.OrderBys.Add(new OrderBy(column, direction));
return(this);
}
private IEnumerable <TResult> GetConverterEnumerator <TResult>(Expression <Func <TDataRecord, TResult> > converter)
{
NewExpression newExpression = converter.Body as NewExpression;
if (newExpression == null)
{
throw new ArgumentException("Must be an expression of type 'NewExpression'.");
}
List <string> sourceNames = new List <string>();
Func <TDataRecord, TResult> func = converter.Compile();
foreach (Expression argument in newExpression.Arguments)
{
MemberExpression memberExpression = argument as MemberExpression;
if (memberExpression == null)
{
continue;
}
sourceNames.Add(memberExpression.Member.Name);
}
IQueryableColumn[] columns = new IQueryableColumn[sourceNames.Count];
for (int i = 0; i < sourceNames.Count; i++)
{
columns[i] = DataRecord <TDataRecord> .Table.FindColumn(sourceNames[i]);
}
QueryTree.Columns.AddRange(columns);
return(Session.QueryManyInternal <TDataRecord>(QueryTree).Select(func));
}
internal OrderBy(IQueryableColumn column, OrderByDirection direction)
{
Argument.Assert.IsNotNull(column, Argument.Names.column);
this.column = column;
this.direction = direction;
}
public EntitySet <T> Select(IQueryableColumn column)
{
Argument.Assert.IsNotNull(column, nameof(column));
QueryTree.Columns.Add(column);
return(this);
}
public JoinPredicate(IQueryableColumn fromColumn, Comparison comparison, IQueryableColumn toColumn)
{
// if (toColumn != null && fromColumn != null && fromColumn.Table == toColumn.Table)
// throw new NotSupportedException("Self referential table joins are not supported in this version.");
FromColumn = fromColumn;
Comparison = comparison;
ToColumn = toColumn;
}
public ColumnPredicate(IQueryableColumn column, object value, object value2)
{
Comparison = Comparison.Between;
Column = column;
Value = value;
Value2 = value2;
convertibleValue = Value as IConvertible;
convertibleValue2 = Value2 as IConvertible;
}
/// <summary>
/// Adds a group by clause on the specified columns.
/// </summary>
/// <param name="column1"></param>
/// <param name="column2"></param>
/// <returns></returns>
public EntitySet <T> GroupBy(IQueryableColumn column1, IQueryableColumn column2)
{
Argument.Assert.IsNotNull(column1, nameof(column1));
Argument.Assert.IsNotNull(column2, nameof(column2));
QueryTree.GroupBys.Add(column1);
QueryTree.GroupBys.Add(column2);
return(this);
}
public EntitySet <T> OrderBy(IQueryableColumn column1, IQueryableColumn column2)
{
Argument.Assert.IsNotNull(column1, nameof(column1));
Argument.Assert.IsNotNull(column2, nameof(column2));
QueryTree.OrderBys.Add(new OrderBy(column1, OrderByDirection.Asc));
QueryTree.OrderBys.Add(new OrderBy(column2, OrderByDirection.Asc));
return(this);
}
private TableColumnData(TableData table, string columnName, DbType dbType, int maxLength, ColumnProperties columnProperties, string defaultValue, string alias, QueryColumn foreignKeyColumn, IQueryableColumn localizedColumn)
{
this.table = table;
this.localizedColumn = localizedColumn;
this.foreignKeyColumn = foreignKeyColumn;
this.alias = alias;
this.defaultValue = defaultValue;
this.columnProperties = columnProperties;
this.dbType = dbType;
this.maxLength = maxLength;
this.columnName = columnName;
}
public Dictionary <TKey, TDataRecord> ToDictionary <TKey>(IQueryableColumn keyColumn)
{
DynamicProperty <TDataRecord> keyProperty = DataEntity <TDataRecord> .Properties[keyColumn.Name];
Dictionary <TKey, TDataRecord> dictionary = new Dictionary <TKey, TDataRecord>();
foreach (TDataRecord item in this)
{
dictionary.Add((TKey)keyProperty.InvokeGetter(item), item);
}
return(dictionary);
}
protected virtual string FormatPredicateColumnName(IQueryableColumn column)
{
if (column == null)
{
return(null);
}
if (Compare.IsNullOrEmpty(GetTableAlias(column.Table)))
{
return(string.Format("[{0}].[{1}].[{2}]", column.Table.Owner, column.Table.Name, column.Name));
}
return(string.Format("{0}.[{1}]", GetTableAlias(column.Table), column.Name));
}
private void AppendSelectClauseAlias(IQueryableColumn column, bool withSpace = false)
{
string alias;
tableAliases.TryGetValue(column.Table, out alias);
if (alias == null)
{
alias = (withSpace ? " " : null) + "_t" + tableAliases.Count;
tableAliases.Add(column.Table, alias);
}
builder.Append(alias);
}
public ColumnPredicate(IQueryableColumn column, Comparison comparison, object value)
{
//BUG: What if parameter value is not a supported SqlParameter type.
if (comparison == Comparison.Between)
{
throw new NotSupportedException("Between comparison requires two values. Use the ColumnPredicate(IQueryableColumn, object, object) overload.");
}
Comparison = comparison;
Column = column;
Value = value;
convertibleValue = Value as IConvertible;
}
private static bool ShouldTryAutoJoin(IQueryableColumn current, QueryTree queryTree)
{
if (!SchemaCompare.TablesAreSame(current.Table, queryTree.Table))
{
foreach (JoinPredicate join in queryTree.Joins)
{
if (SchemaCompare.TablesAreSame(join.ToColumn.Table, current.Table))
{
return(false);
}
}
return(true);
}
return(false);
}
public static bool ColumnsAreSame(IQueryableColumn a, IQueryableColumn b)
{
if (a == null || b == null)
{
return(false);
}
if (ReferenceEquals(a, b))
{
return(true);
}
return(Compare.AreSameOrdinal(a.Name, b.Name) &&
Compare.AreSameOrdinal(a.Table.Name, b.Table.Name) &&
Compare.AreSameOrdinal(a.Table.Owner, b.Table.Owner));
}
internal object this[IQueryableColumn column]
{
get
{
if (column == null)
{
return(null);
}
DynamicProperty <TDataRecord> property = Properties[column.Name];
return(property == null ? null : property.InvokeGetter((TDataRecord)this));
}
set
{
DynamicProperty <TDataRecord> property = Properties[column.Name];
if (property != null)
{
property.InvokeSetter((TDataRecord)this, value);
}
}
}
public virtual void WritePredicate(IQueryableColumn column, string comparisonOperator, ParameterNames parameterNames)
{
string columText = FormatPredicateColumnName(column);
if (column.ColumnFormat != null)
{
columText = string.Format(column.ColumnFormat, columText);
}
if (parameterNames == ParameterNames.Empty)
{
Write(Formats.NullComparisonPredicateFormat, columText, comparisonOperator);
}
else if (parameterNames.Parameter1 != null && parameterNames.Parameter2 != null)
{
Write(Formats.RangePredicateFormat, columText, comparisonOperator, parameterNames.Parameter1, parameterNames.Parameter2);
}
else
{
Write(Formats.DefaultPredicateFormat, columText, comparisonOperator, parameterNames.Parameter1);
}
}
protected virtual string FormatPredicateSelectColumnName(IQueryableColumn column, bool useTableAlias, bool useColumnAlias)
{
string name;
if (Compare.IsNullOrEmpty(GetTableAlias(column.Table)))
{
name = string.Format(Formats.ColumnFormatNoAlias, column.Table.Owner, column.Table.Name, column.Name);
}
else if (useTableAlias)
{
name = string.Format(Formats.ColumnFormatAlias, GetTableAlias(column.Table), column.Name);
}
else
{
name = string.Format(Formats.ColumnFormatSubquery, column.Name);
}
if (column.ColumnFormat != null)
{
name = string.Format(column.ColumnFormat, name);
}
if (column.LocalizeFallbackColumn != null)
{
name = string.Format("ISNULL({0}, {1}) AS {2}",
name,
FormatPredicateSelectColumnName(column.LocalizeFallbackColumn, true, false),
column.Alias ?? column.Name);
useColumnAlias = false;
}
if (useColumnAlias && !Compare.IsNullOrEmpty(column.Alias))
{
name += " AS " + column.Alias;
}
return(name);
}
public static bool ColumnsAreSame(IQueryableColumn column, PrimaryKeys keys)
{
foreach (IQueryableColumn b in keys)
{
if (column == null || b == null)
{
return(false);
}
if (ReferenceEquals(column, b))
{
return(true);
}
if (Compare.AreSameOrdinal(column.Name, b.Name) &&
Compare.AreSameOrdinal(column.Table.Name, b.Table.Name) &&
Compare.AreSameOrdinal(column.Table.Owner, b.Table.Owner))
{
return(true);
}
}
return(false);
}
public void AppendSelect(IQueryableColumn selectColumn)
{
string currentCulture = CultureInfo.CurrentCulture.Name;
if (!session.UseDefaultLocale && session.DefaultLocale != currentCulture && session.IsLanguageSupported(currentCulture))
{
IQueryableColumn localizedColumn = selectColumn.LocalizedColumn;
if (localizedColumn != null)
{
localizedColumn = localizedColumn.As(selectColumn.Alias);
ColumnPredicate localizePredicate = (localizedColumn.Table.FindColumn("Locale") == currentCulture) | (localizedColumn.Table.FindColumn("Locale") == null);
if (!((ICommandBuilder)this).WherePredicates.Contains(localizePredicate))
{
((ICommandBuilder)this).WherePredicates.Add(localizePredicate);
}
localizedColumn.LocalizeFallbackColumn = selectColumn;
Columns.Add(localizedColumn);
foreach (QueryColumn primaryKey in selectColumn.Table.PrimaryKey)
{
JoinPredicate joinPredicate = primaryKey == localizedColumn.Table.FindColumn(primaryKey.Name);
if (!LocalizedJoinPredicates.Contains(joinPredicate))
{
LocalizedJoinPredicates.Add(joinPredicate);
}
}
JoinInWhereClause = false;
return;
}
}
AppendFrom(selectColumn.Table);
Columns.Add(selectColumn);
}
public CountAggregate(IQueryableColumn column) : base(column)
{
}
public AverageAggregate(IQueryableColumn column) : base(column)
{
}
public static ColumnAggregate IsNull(this IQueryableColumn column, object defaultValue)
{
// throw new NotImplementedException("Still needs some work on format of default value.");
return(new IsNullFunction(column, defaultValue));
}
