public void CreateIndexProperly(IndexType indexType, bool isUnique, ColumnSort columnSort)
{
string indexName = "IX_Test";
Table table = fixture.table;
List <Tuple <Column, ColumnSort> > indexColumns = new List <Tuple <Column, ColumnSort> >();
table.Columns.ForEach(c =>
{
indexColumns.Add(Tuple.Create(c, columnSort));
TableIndex index = new TableIndex(indexName, table, indexColumns.ToArray())
{
IsUnique = isUnique,
IndexType = indexType
};
using (SqlConnection sqlConnection = new SqlConnection(connectionString))
{
sqlConnection.Open();
index.Create(sqlConnection);
using (SqlCommand sqlCommand = sqlConnection.CreateCommand())
{
string sql = $@"
SELECT COUNT(*)
FROM sys.indexes
JOIN sys.index_columns
ON sys.indexes.object_id = sys.index_columns.object_id
where name = '{indexName}'";
sqlCommand.CommandText = sql;
int columnCount = (int)sqlCommand.ExecuteScalar();
Assert.Equal(indexColumns.Count, columnCount);
sql = $@"
SELECT OBJECT_NAME(sys.indexes.object_id), name, type_desc, is_unique, is_descending_key
FROM sys.indexes
JOIN sys.index_columns
ON sys.indexes.object_id = sys.index_columns.object_id
where name = '{indexName}'";
sqlCommand.CommandText = sql;
using (SqlDataReader sqlDataReader = sqlCommand.ExecuteReader())
{
while (sqlDataReader.Read())
{
Assert.Equal(table.Name, sqlDataReader.GetString(0));
Assert.Equal(index.Name, sqlDataReader.GetString(1));
Assert.Equal(indexType.ToString(), sqlDataReader.GetString(2));
Assert.Equal(isUnique, sqlDataReader.GetBoolean(3));
Assert.Equal(columnSort == ColumnSort.DESC, sqlDataReader.GetBoolean(4));
}
}
}
index.Drop(sqlConnection);
}
});
}
public async Task <ActionResult <SitesObj> > GetSite(string search, string postcode, int brand, int limit = 10, int page = 1, int sortby = 0)
{
var sites = _context.Site.AsQueryable();
if (brand != 0)
{
sites = sites.Where(s => s.BrandId == brand);
}
if (!string.IsNullOrEmpty(search))
{
sites = sites.Where(s => s.Name.ToLower().Contains(search.ToLower()));
}
if (!string.IsNullOrEmpty(postcode))
{
sites = sites.Where(s => s.PostCode.Contains(postcode));
}
var siteView = sites.Select(s => new SiteView
{
Id = s.Id,
Name = s.Name,
Brand = s.Brand.Name,
Address = s.Address,
PostCode = s.PostCode,
Latitude = s.Latitude,
Longitude = s.Longitude,
RegionLevel1 = s.SiteRegion.Where(sr => sr.Region.GeographicalLevel == 1).Select(sr => sr.Region.Name).First(),
RegionLevel2 = s.SiteRegion.Where(sr => sr.Region.GeographicalLevel == 2).Select(sr => sr.Region.Name).First(),
ModifiedDate = s.ModifiedDate,
});
ColumnSort column = new ColumnSort();
if (sortby < 0 || sortby > 3)
{
return(BadRequest());
}
else
{
column = (ColumnSort)sortby;
}
siteView = siteView.OrderBy(s => EF.Property <SiteView>(s, column.ToString()));
SitesObj sitesObj = new SitesObj();
sitesObj.QueryInfo.RowCount = await siteView.CountAsync();
sitesObj.Sites = await siteView
.Skip(limit *(page - 1))
.Take(limit)
.ToListAsync();
return(sitesObj);
}
private static ColumnSort[] GetColumns(KeyOutput _, CandidateKey primaryKey)
{
var result = new ColumnSort[primaryKey.Count];
for (int i = 0; i < primaryKey.Count; i++)
{
var columnSort = primaryKey[i];
result[i] = new ColumnSort(columnSort.Column.Clone(_), columnSort.Direction);
}
return(result);
}
private static ColumnSort[] GetOrderBy(Model model, IReadOnlyList <IColumnComparer> orderBy)
{
Debug.Assert(orderBy != null && orderBy.Count > 0);
var result = new ColumnSort[orderBy.Count];
for (int i = 0; i < orderBy.Count; i++)
{
var column = orderBy[i].GetColumn(model);
var direction = orderBy[i].Direction;
result[i] = direction == SortDirection.Descending ? column.Desc() : column.Asc();
}
return(result);
}
/// <summary>
/// Initializes a new instance of <see cref="KeyOutput"/> class.
/// </summary>
/// <param name="model">The source model.</param>
public KeyOutput(Model model)
{
model.VerifyNotNull(nameof(model));
var primaryKey = model.PrimaryKey;
if (primaryKey == null)
{
throw new ArgumentException(DiagnosticMessages.DbTable_NoPrimaryKey(model), nameof(model));
}
_sourceDbAlias = model.DbAlias;
_primaryKey = new PK(this, primaryKey);
var sortKeys = new ColumnSort[primaryKey.Count];
for (int i = 0; i < sortKeys.Length; i++)
{
sortKeys[i] = primaryKey[i];
}
AddDbTableConstraint(new DbPrimaryKey(this, null, null, false, () => { return(sortKeys); }), true);
}
static void Main(string[] args)
{
//var factory = new Factory();
//var callbackA = factory.Create(Factory.CallbackType.CallbackA);
//callbackA.InitCallback();
//var callbackB = factory.Create(Factory.CallbackType.CallbackB);
//callbackB.InitCallback();
var unSortArray = new int[, ] {
{ 10, 14, 5 },
{ 8, 7, 17 },
{ 12, 1, 6 },
{ 16, 9, 11 },
{ 4, 15, 2 },
{ 18, 3, 13 }
};
for (int i = 0; i < unSortArray.GetLength(0); i++)
{
for (int ii = 0; ii < unSortArray.GetLength(1); ii++)
{
Console.Write(unSortArray[i, ii].ToString().PadLeft(2, ' ') + " ");
}
Console.WriteLine();
}
Console.WriteLine();
var sortList = ColumnSort.Sort(unSortArray);
for (int i = 0; i < sortList.GetLength(0); i++)
{
for (int ii = 0; ii < sortList.GetLength(1); ii++)
{
Console.Write(sortList[i, ii].ToString().PadLeft(2, ' ') + " ");
}
Console.WriteLine();
}
Console.ReadKey();
////-4 0, 2 5 6 11 18 22 51 167
//int[] array = new int []{ 2, 5, -4, 11, 0, 18, 22, 167, 51, 6 };
//List<int> list = new List<int>();
//list.AddRange(array);
//var sortList = RadixSort.Sort(list);
//foreach(var value in sortList)
//{
// Console.WriteLine(value);
//}
////IReceiver
//Power power = new Power();
//Button button = new Button();
////ICommand
//ButtonCommand buttonCommand = new ButtonCommand(button);
//PowerOffCommand powerOffCommand = new PowerOffCommand(power);
//PowerOnCommand powerOnCommand = new PowerOnCommand(power);
////Invoke
//var remote = new Remote();
//remote.Appand(buttonCommand).Appand(powerOffCommand).Appand(powerOnCommand);
//remote.PowerOff();
//remote.PowerOn();
//remote.Click();
}
public PrimaryKeyConstraint AddColumn(Column column, ColumnSort sortOrder = ColumnSort.ASC)
{
columns.Add(new Tuple <Column, ColumnSort>(column, sortOrder));
return(this);
}
public PrimaryKeyConstraint(string name, Column column, ColumnSort sortOrder = ColumnSort.ASC) : base(name)
{
AddColumn(column, sortOrder);
}
public PrimaryKeyConstraint(Column column, ColumnSort sortOrder = ColumnSort.ASC) : base(null)
{
AddColumn(column, sortOrder);
}
public UniqueConstraint(string name, Column column, ColumnSort sortOrder = ColumnSort.ASC) : base(name)
{
AddColumn(column, sortOrder);
}
public UniqueConstraint(Column column, ColumnSort sortOrder = ColumnSort.ASC) : this(null, column, sortOrder)
{
}
public static RowFilter ReadXml(XmlReader reader)
{
var rowFilter = new RowFilter();
rowFilter.Text = reader.GetAttribute("text");
if (!string.IsNullOrEmpty(rowFilter.Text))
{
rowFilter.CaseSensitive = reader.GetAttribute("caseSensitive") != null;
}
if (reader.IsEmptyElement)
{
reader.Read();
return(rowFilter);
}
reader.Read();
var columnFilters = new List <ColumnFilter>();
var columnSorts = new List <ColumnSort>();
while (true)
{
if (reader.IsStartElement("columnFilter"))
{
var columnFilter = new ColumnFilter(new ColumnId(reader.GetAttribute("column")), FilterPredicate.ReadXml(reader));
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.Read();
reader.ReadEndElement();
}
columnFilters.Add(columnFilter);
}
else if (reader.IsStartElement("columnSort"))
{
var direction = Equals(SORT_DESC, reader.GetAttribute("direction"))
? ListSortDirection.Descending
: ListSortDirection.Ascending;
var columnSort = new ColumnSort(new ColumnId(reader.GetAttribute("column")), direction);
columnSorts.Add(columnSort);
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.Read();
reader.ReadEndElement();
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
break;
}
else
{
reader.Read();
}
}
rowFilter.ColumnFilters = ImmutableList.ValueOf(columnFilters);
rowFilter.ColumnSorts = ImmutableList.ValueOf(columnSorts);
return(rowFilter);
}
protected bool Equals(ColumnSort other)
{
return(ColumnId.Equals(other.ColumnId) && ListSortDirection == other.ListSortDirection);
}
void GtkColumn_Clicked(object sender, EventArgs e)
{
TreeViewColumn gtkColumn = (TreeViewColumn)sender;
GridColumn clickedColumn = columns.FirstOrDefault(x => x.GtkColumn == gtkColumn);
if (clickedColumn == null)
{
Debug.WriteLine("Grid: Error: Missing column reference");
return;
}
bool multiSortKey = (currentModifierKeys & (ModifierType.ShiftMask | ModifierType.ControlMask)) != 0;
int foundIndex = columnSorts.FindIndex(x => x.Column == clickedColumn);
ColumnSort columnSort = null;
if (foundIndex >= 0)
{
columnSort = columnSorts[foundIndex];
}
if (!multiSortKey)
{
// If we were doing some kind of multi-column sorting, then start over
if (columnSorts.Count != 1 || foundIndex < 0 || columnSorts[foundIndex].Column != clickedColumn)
{
columnSorts.Clear();
columnSort = null;
foundIndex = -1;
}
}
if (columnSort != null && foundIndex == columnSorts.Count - 1)
{
// The user clicked the header for the column that was most recently included in the sort
switch (columnSort.Direction)
{
case SortType.Ascending:
columnSort.Direction = SortType.Descending;
break;
case SortType.Descending:
if (columnSorts.Count == 1)
{
columnSorts.RemoveAt(foundIndex);
}
else
{
columnSort.Direction = SortType.Ascending;
}
break;
}
}
else if (columnSort != null)
{
// The user clicked the header for a column that is already in the sort;
// start over with a new compound key
columnSorts.Clear();
columnSorts.Add(columnSort);
columnSort.Direction = SortType.Ascending;
}
else
{
// The user is adding a new column to the sort
columnSorts.Add(new ColumnSort()
{
Column = clickedColumn, Direction = SortType.Ascending
});
}
// Update the visual display
foreach (var column in columns)
{
columnSort = columnSorts.FirstOrDefault(x => x.Column == column);
if (columnSort != null)
{
column.GtkColumn.SortIndicator = true;
column.GtkColumn.SortOrder = columnSort.Direction;
}
else
{
column.GtkColumn.SortIndicator = false;
}
}
UpdateView();
}
