private bool GetOrderValuesCaseSensitiveFromTables(SelectCommandContext selectCommandContext, SchemaMetaData schemaMetaData, OrderByItem eachOrderByItem)
{
foreach (var simpleTableSegment in selectCommandContext.GetAllTables())
{
var tableName = simpleTableSegment.GetTableName().GetIdentifier().GetValue();
var tableMetaData = schemaMetaData.Get(tableName);
IDictionary <String, ColumnMetaData> columns = tableMetaData.GetColumns();
var orderByItemSegment = eachOrderByItem.GetSegment();
if (orderByItemSegment is ColumnOrderByItemSegment columnOrderByItemSegment)
{
String columnName = columnOrderByItemSegment.GetColumn().GetIdentifier().GetValue();
if (columns.ContainsKey(columnName))
{
return(columns[columnName].CaseSensitive);
}
}
else if (orderByItemSegment is IndexOrderByItemSegment indexOrderByItemSegment)
{
int columnIndex = indexOrderByItemSegment.GetColumnIndex();
String columnName = _streamDataReader.GetColumnName(columnIndex);
if (columns.ContainsKey(columnName))
{
return(columns[columnName].CaseSensitive);
}
}
else
{
return(false);
}
}
return(false);
}
public GroupByStreamMergedDataReader(IDictionary <string, int> labelAndIndexMap, List <IStreamDataReader> streamDataReaders, SelectCommandContext selectCommandContext, SchemaMetaData schemaMetaData) : base(streamDataReaders, selectCommandContext, schemaMetaData)
{
this._selectCommandContext = selectCommandContext;
_currentRow = new List <object>(labelAndIndexMap.Count);
_currentGroupByValues = OrderByValuesQueue.IsEmpty()
? new List <object>(0) : new GroupByValue(GetCurrentStreamDataReader(), selectCommandContext.GetGroupByContext().GetItems()).GetGroupValues();
}
private List <MemoryQueryResultRow> GetMemoryResultSetRows(SelectCommandContext selectCommandContext,
IDictionary <GroupByValue, MemoryQueryResultRow> dataMap, List <bool> valueCaseSensitive)
{
List <MemoryQueryResultRow> result = new List <MemoryQueryResultRow>(dataMap.Values);
result.Sort(new GroupByRowComparator(selectCommandContext, valueCaseSensitive));
return(result);
}
/**
* Get revised row count.
*
* @param shardingStatement sharding optimized statement
* @return revised row count
*/
public long GetRevisedRowCount(SelectCommandContext shardingCommand)
{
if (IsMaxRowCount(shardingCommand))
{
return(int.MaxValue);
}
return(_rowCountSegment is LimitValueSegment ? _actualOffset + _actualRowCount.GetValueOrDefault() : _actualRowCount.GetValueOrDefault());
}
private void SetGroupByForDistinctRow(SelectCommandContext selectCommandContext)
{
for (int index = 0; index < selectCommandContext.GetProjectionsContext().GetExpandProjections().Count; index++)
{
OrderByItem orderByItem = new OrderByItem(new IndexOrderByItemSegment(-1, -1, index, OrderDirectionEnum.ASC, OrderDirectionEnum.ASC));
orderByItem.SetIndex(index);
selectCommandContext.GetGroupByContext().GetItems().Add(orderByItem);
}
}
private List <bool> GetOrderValuesCaseSensitive(SelectCommandContext selectCommandContext, SchemaMetaData schemaMetaData)
{
List <bool> result = new List <bool>(orderByItems.Count);
foreach (var orderByItem in orderByItems)
{
result.Add(GetOrderValuesCaseSensitiveFromTables(selectCommandContext, schemaMetaData, orderByItem));
}
return(result);
}
private void SetAggregationValueToMemoryRow(SelectCommandContext selectCommandContext,
IDictionary <GroupByValue, MemoryQueryResultRow> dataMap, IDictionary <GroupByValue, IDictionary <AggregationProjection, IAggregationUnit> > aggregationMap)
{
foreach (var dataKv in dataMap)
{
var aggregationProjections = selectCommandContext.GetProjectionsContext().GetAggregationProjections();
foreach (var aggregationProjection in aggregationProjections)
{
dataKv.Value.SetCell(aggregationProjection.GetIndex(), aggregationMap.Get(dataKv.Key).Get(aggregationProjection).GetResult());
}
}
}
private void InitForFirstGroupByValue(SelectCommandContext selectCommandContext, IStreamDataReader streamDataReader,
GroupByValue groupByValue, IDictionary <GroupByValue, MemoryQueryResultRow> dataMap,
IDictionary <GroupByValue, IDictionary <AggregationProjection, IAggregationUnit> > aggregationMap)
{
if (!dataMap.ContainsKey(groupByValue))
{
dataMap.Add(groupByValue, new MemoryQueryResultRow(streamDataReader));
}
if (!aggregationMap.ContainsKey(groupByValue))
{
var map = selectCommandContext.GetProjectionsContext().GetAggregationProjections().ToDictionary(o => o,
o => AggregationUnitFactory.Create(o.GetAggregationType(), o is AggregationDistinctProjection));
aggregationMap.Add(groupByValue, map);
}
}
private IStreamDataReader Build(List <IStreamDataReader> streamDataReaders, SelectCommandContext selectCommandContext,
IDictionary <string, int> columnLabelIndexMap, SchemaMetaData schemaMetaData)
{
if (IsNeedProcessGroupBy(selectCommandContext))
{
return(GetGroupByMergedResult(streamDataReaders, selectCommandContext, columnLabelIndexMap, schemaMetaData));
}
if (IsNeedProcessDistinctRow(selectCommandContext))
{
SetGroupByForDistinctRow(selectCommandContext);
return(GetGroupByMergedResult(streamDataReaders, selectCommandContext, columnLabelIndexMap, schemaMetaData));
}
if (IsNeedProcessOrderBy(selectCommandContext))
{
return(new OrderByStreamMergedDataReader(streamDataReaders, selectCommandContext, schemaMetaData));
}
return(new IteratorStreamMergedDataReader(streamDataReaders));
}
private void Aggregate(SelectCommandContext selectCommandContext, IStreamDataReader streamDataReader,
GroupByValue groupByValue, IDictionary <GroupByValue, IDictionary <AggregationProjection, IAggregationUnit> > aggregationMap)
{
var aggregationProjections = selectCommandContext.GetProjectionsContext().GetAggregationProjections();
foreach (var aggregationProjection in aggregationProjections)
{
List <IComparable> values = new List <IComparable>(2);
if (aggregationProjection.GetDerivedAggregationProjections().IsEmpty())
{
values.Add(GetAggregationValue(streamDataReader, aggregationProjection));
}
else
{
foreach (var derived in aggregationProjection.GetDerivedAggregationProjections())
{
values.Add(GetAggregationValue(streamDataReader, derived));
}
}
aggregationMap.Get(groupByValue).Get(aggregationProjection).Merge(values);
}
}
public GroupByMemoryMergedDataReader(List <IStreamDataReader> queryDataReaders, SelectCommandContext sqlCommandContext, SchemaMetaData schemaMetaData) : base(null, schemaMetaData, sqlCommandContext, queryDataReaders)
{
}
private bool GetValueCaseSensitiveFromTables(IStreamDataReader streamDataReader, SelectCommandContext selectCommandContext,
SchemaMetaData schemaMetaData, int columnIndex)
{
foreach (var simpleTableSegment in selectCommandContext.GetAllTables())
{
String tableName = simpleTableSegment.GetTableName().GetIdentifier().GetValue();
TableMetaData tableMetaData = schemaMetaData.Get(tableName);
IDictionary <String, ColumnMetaData> columns = tableMetaData.GetColumns();
String columnName = streamDataReader.GetColumnName(columnIndex);
if (columns.ContainsKey(columnName))
{
return(columns[columnName].CaseSensitive);
}
}
return(false);
}
private IStreamDataReader Decorate(List <IStreamDataReader> streamDataReaders, SelectCommandContext selectCommandContext, IStreamDataReader mergedStreamDataReader)
{
var paginationContext = selectCommandContext.GetPaginationContext();
if (!paginationContext.HasPagination() || 1 == streamDataReaders.Count)
{
return(mergedStreamDataReader);
}
String trunkDatabaseName = DatabaseTypes.GetTrunkDatabaseType(_databaseType.GetName()).GetName();
if ("MySql".Equals(trunkDatabaseName) || "PostgreSQL".Equals(trunkDatabaseName))
{
return(new LimitDecoratorStreamDataReader(mergedStreamDataReader, paginationContext));
}
if ("Oracle".Equals(trunkDatabaseName))
{
return(new RowNumberDecoratorStreamDataReader(mergedStreamDataReader, paginationContext));
}
if ("SQLServer".Equals(trunkDatabaseName))
{
return(new TopAndRowNumberDecoratorStreamDataReader(mergedStreamDataReader, paginationContext));
}
return(mergedStreamDataReader);
}
private bool IsMaxRowCount(SelectCommandContext shardingCommand)
{
return((shardingCommand.GetGroupByContext().GetItems().Any() ||
shardingCommand.GetProjectionsContext().GetAggregationProjections().Any()) && !shardingCommand.IsSameGroupByAndOrderByItems());
}
private bool IsNeedProcessDistinctRow(SelectCommandContext selectCommandContext)
{
return(selectCommandContext.GetProjectionsContext().IsDistinctRow());
}
private bool IsNeedProcessGroupBy(SelectCommandContext selectCommandContext)
{
return(!selectCommandContext.GetGroupByContext().GetItems().IsEmpty() || !selectCommandContext.GetProjectionsContext().GetAggregationProjections().IsEmpty());
}
public GroupByRowComparator(SelectCommandContext selectCommandContext, List <bool> valueCaseSensitive)
{
this.selectCommandContext = selectCommandContext;
this.valueCaseSensitive = valueCaseSensitive;
}
public OrderByValue(IStreamDataReader streamDataReader, ICollection <OrderByItem> orderByItems, SelectCommandContext selectCommandContext, SchemaMetaData schemaMetaData)
{
this._streamDataReader = streamDataReader;
this.orderByItems = orderByItems;
this.orderValuesCaseSensitive = GetOrderValuesCaseSensitive(selectCommandContext, schemaMetaData);
}
public OrderByStreamMergedDataReader(List <IStreamDataReader> streamDataReaders, SelectCommandContext selectCommandContext, SchemaMetaData schemaMetaData)
{
this.OrderByItems = selectCommandContext.GetOrderByContext().GetItems();
this.OrderByValuesQueue = new PriorityQueue <OrderByValue>(streamDataReaders.Count);
OrderResultSetsToQueue(streamDataReaders, selectCommandContext, schemaMetaData);
IsFirstNext = true;
}
private IStreamDataReader GetGroupByMergedResult(List <IStreamDataReader> streamDataReaders, SelectCommandContext selectCommandContext,
IDictionary <string, int> columnLabelIndexMap, SchemaMetaData schemaMetaData)
{
if (selectCommandContext.IsSameGroupByAndOrderByItems())
{
return(new GroupByStreamMergedDataReader(columnLabelIndexMap, streamDataReaders, selectCommandContext,
schemaMetaData));
}
return(new GroupByMemoryMergedDataReader(streamDataReaders, selectCommandContext, schemaMetaData));
}
private bool IsNeedProcessOrderBy(SelectCommandContext selectCommandContext)
{
return(!selectCommandContext.GetOrderByContext().GetItems().IsEmpty());
}
private void OrderResultSetsToQueue(List <IStreamDataReader> streamDataReaders, SelectCommandContext selectCommandContext, SchemaMetaData schemaMetaData)
{
foreach (var queryResult in streamDataReaders)
{
OrderByValue orderByValue = new OrderByValue(queryResult, OrderByItems, selectCommandContext, schemaMetaData);
if (orderByValue.MoveNext())
{
OrderByValuesQueue.Offer(orderByValue);
}
}
SetCurrentStreamDataReader(OrderByValuesQueue.IsEmpty() ? streamDataReaders[0] : OrderByValuesQueue.Peek().GetStreamDataReader());
}
private List <bool> GetValueCaseSensitive(IStreamDataReader streamDataReader, SelectCommandContext selectCommandContext, SchemaMetaData schemaMetaData)
{
List <bool> result = new List <bool>(streamDataReader.ColumnCount + 1)
{
false
};
for (int columnIndex = 0; columnIndex < streamDataReader.ColumnCount; columnIndex++)
{
result.Add(GetValueCaseSensitiveFromTables(streamDataReader, selectCommandContext, schemaMetaData, columnIndex));
}
return(result);
}
