/// <summary>
/// Replaces the current OrderBy clause
/// </summary>
/// <param name="queryBuilder"></param>
/// <param name="or"></param>
/// <returns></returns>
public static IQueryBuilder OrderBy(this IQueryBuilder queryBuilder, IOrderBy orderBy)
{
var qb = queryBuilder.Clone();
qb.QueryDef.OrderBy.Clear();
qb.QueryDef.OrderBy.Add(orderBy);
return qb;
}
public void Add()
{
IAlias person = sql.Alias("person");
IOrderBy orderBy = sql.OrderBy()
.Add(person["Name"])
.Add(person["SurName"]);
QueryResult result = engine.Compile(orderBy);
Assert.Equal("ORDER BY \"person\".\"Name\", \"person\".\"SurName\"", result.Sql);
Assert.Equal(new Dictionary <string, object>(), result.Parameters);
}
public void Add_Expression_With_Order()
{
Person person = null;
IOrderBy orderBy = sql.OrderBy()
.Add(() => person.Name).Asc
.Add(() => person.SurName).Desc;
QueryResult result = engine.Compile(orderBy);
Assert.Equal("ORDER BY \"person\".\"Name\" ASC, \"person\".\"SurName\" DESC", result.Sql);
Assert.Equal(new Dictionary <string, object>(), result.Parameters);
}
public static OrgEmployeesList GetList(IWhere whereClause, IOrderBy orderByClause)
{
SqlDataReader dataReader = GetListReader(DatabaseEnum.INTRANET, TABLE, whereClause, orderByClause, true);
OrgEmployeesList list = new OrgEmployeesList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public static GroupList GetList(IWhere whereClause, IOrderBy orderByClause)
{
SqlDataReader dataReader = GetListReader(DatabaseEnum.ORDERDB, TABLE, whereClause, orderByClause, true);
GroupList list = new GroupList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public static KnowledgebasesArticleTextList GetList(IWhere whereClause, IOrderBy orderByClause)
{
SqlDataReader dataReader = GetListReader(DatabaseEnum.INTRANET, TABLE, whereClause, orderByClause, true);
KnowledgebasesArticleTextList list = new KnowledgebasesArticleTextList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public void Add_Enumerable_With_Order()
{
IAlias person = sql.Alias("person");
IOrderBy orderBy = sql.OrderBy().Add(new List <object> {
person["Name"], person["SurName"]
}).Desc;
QueryResult result = engine.Compile(orderBy);
Assert.Equal("ORDER BY \"person\".\"Name\" DESC, \"person\".\"SurName\" DESC", result.Sql);
Assert.Equal(new Dictionary <string, object>(), result.Parameters);
}
public void Add_Expression_Enumerable()
{
Person person = null;
IOrderBy orderBy = sql.OrderBy().Add(new List <Expression <Func <object> > > {
() => person.Name,
() => person.SurName
});
QueryResult result = engine.Compile(orderBy);
Assert.Equal("ORDER BY \"person\".\"Name\", \"person\".\"SurName\"", result.Sql);
Assert.Equal(new Dictionary <string, object>(), result.Parameters);
}
/// <summary>
/// Returns an ordered and filtered list of Payment rows.
/// </summary>
/// <param name="whereClause">Filtering criteria.</param>
/// <param name="orderByClause">Ordering criteria.</param>
/// <returns>List of PaymentData objects.</returns>
/// <exception cref="Spring2.Core.DAO.FinderException">Thrown when no rows are found matching the where criteria.</exception>
public static IList GetList(IWhere whereClause, IOrderBy orderByClause, Int32 maxRows)
{
SqlDataReader dataReader = GetListReader(CONNECTION_STRING_KEY, VIEW, whereClause, orderByClause, maxRows);
ArrayList list = new ArrayList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
/// <summary>
/// Returns an ordered and filtered list of MailMessage rows.
/// </summary>
/// <param name="filter">Filtering criteria.</param>
/// <param name="orderByClause">Ordering criteria.</param>
/// <returns>List of MailMessage objects.</returns>
/// <exception cref="Spring2.Core.DAO.FinderException">Thrown when no rows are found matching the where criteria.</exception>
public MailMessageList GetList(SqlFilter filter, IOrderBy orderByClause)
{
IDataReader dataReader = GetListReader(CONNECTION_STRING_KEY, VIEW, filter, orderByClause);
MailMessageList list = new MailMessageList();
while (dataReader.Read())
{
list.Add(GetDataObjectFromReader(dataReader));
}
dataReader.Close();
return(list);
}
public void Order_Not_Column()
{
IAlias person = sql.Alias("person");
IOrderBy orderBy = sql.OrderBy()
.Add(sql.Case
.When(person["Name"].IsNotNull(), person["Name"])
.Else(person["SurName"])).Desc;
QueryResult result = engine.Compile(orderBy);
Assert.Equal("ORDER BY CASE WHEN \"person\".\"Name\" IS NOT NULL THEN \"person\".\"Name\" "
+ "ELSE \"person\".\"SurName\" END DESC", result.Sql);
Assert.Equal(new Dictionary <string, object>(), result.Parameters);
}
protected IOrderByClause Add(IOrderBy orderBy, AddWhen when)
{
if (orderBy is IOrderByItem)
{
return(Add((IOrderByItem)orderBy, when));
}
else
{
foreach (var item in (IOrderByClause)orderBy)
{
Add(item);
}
return(this);
}
}
/// <summary>
/// Binds the order by query option to the sql builder.
/// </summary>
/// <param name="orderByQueryOption">The order by query.</param>
/// <param name="objectInfo">The IObjectInfo for the type to bind the order by list for.</param>
/// <param name="orderBySqlBuilder">The order by SQL builder.</param>
/// <returns>The SqlBuilder after the order by clause has been added.</returns>
public static IOrderBy BindOrderBy(OrderByQueryOption orderByQueryOption, IObjectInfo objectInfo, IOrderBy orderBySqlBuilder)
{
if (objectInfo == null)
{
throw new ArgumentNullException("objectInfo");
}
if (orderBySqlBuilder == null)
{
throw new ArgumentNullException("orderBySqlBuilder");
}
if (orderByQueryOption != null)
{
for (int i = 0; i < orderByQueryOption.Properties.Count; i++)
{
var property = orderByQueryOption.Properties[i];
var column = objectInfo.TableInfo.GetColumnInfoForProperty(property.Name);
if (column == null)
{
throw new ODataException(string.Format(CultureInfo.InvariantCulture, Messages.InvalidPropertyName, objectInfo.ForType.Name, property.Name));
}
var columnName = column.ColumnName;
if (property.Direction == OrderByDirection.Ascending)
{
orderBySqlBuilder.OrderByAscending(columnName);
}
else
{
orderBySqlBuilder.OrderByDescending(columnName);
}
}
}
return orderBySqlBuilder;
}
public static EventList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
public Task <IEnumerable <WorkflowDefinition> > FindManyAsync(ISpecification <WorkflowDefinition> specification, IOrderBy <WorkflowDefinition>?orderBy = null, IPaging?paging = null, CancellationToken cancellationToken = default) => _store.FindManyAsync(specification, orderBy, paging, cancellationToken);
public Task <IEnumerable <WorkflowSetting> > FindManyAsync(
ISpecification <WorkflowSetting> specification,
IOrderBy <WorkflowSetting>?orderBy,
IPaging?paging,
CancellationToken cancellationToken) =>
_store.FindManyAsync(specification, orderBy, paging, cancellationToken);
public static KnowledgebasesList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
public static OrgGroupsEmployeesList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
public LambdaQueryHelper <T> OrderBy(IOrderBy <T> orderby)
{
return((LambdaQueryHelper <T>)base.OrderBy(orderby.ToOrderByClip()));
}
protected IOrderByClause Add(IOrderBy orderBy, AddWhen when)
{
if (orderBy is IOrderByItem)
{
return Add((IOrderByItem)orderBy, when);
}
else
{
foreach (var item in (IOrderByClause)orderBy)
{
Add(item);
}
return this;
}
}
public static GroupNewsArticlesInfoList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
/// <summary>
/// Returns an ordered list of Payment rows. All rows in the database are returned
/// </summary>
/// <param name="orderByClause">Ordering criteria.</param>
/// <returns>List of PaymentData objects.</returns>
/// <exception cref="Spring2.Core.DAO.FinderException">Thrown when no rows are found.</exception>
public static IList GetList(IOrderBy orderByClause, Int32 maxRows)
{
return(GetList(null, orderByClause, maxRows));
}
public IOrderByClause Add(IOrderBy item)
{
return Add(item, AddWhen.MustBeMissing);
}
public static MustShowControlViewList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
public static IOrderedQueryable <T> OrderBy <T>(this IQueryable <T> source, IOrderBy <T> orderBy) where T : class
{
return(orderBy.GetOption(source));
}
public static NewsArticlesList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
public IOrderByClause AddAlways(IOrderBy item)
{
return Add(item, AddWhen.Always);
}
public static ControlEditList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
protected virtual IQueryNode VisitOrderBy(IOrderBy node)
{
this.Visit(node.Column);
return node;
}
public ICriteria Add(IOrderBy orderBy)
{
_listOrderBy.Add(orderBy);
return(this);
}
public static OrgPhoneNumbersList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
public static WebConfigList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
public IOrderByClause AddIfNotPresent(IOrderBy item)
{
return Add(item, AddWhen.WhenMissing);
}
public static KnowledgebasesSectionsArticlesSeeAlsoList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
public QueryOptionsInput()
{
pagination = new PaginationInput();
query = new QueryInput();
orderBy = new OrderBy();
}
public static CalendarsItemsLocationsList GetList(IOrderBy orderByClause)
{
return(GetList(null, orderByClause));
}
public QueryOptionsInput(IPaginationInput Pagination, IQueryInput Query, IOrderBy OrderBy) : this(Pagination, Query)
{
orderBy = OrderBy;
}
