private IComparable GetAggregationValue(IStreamDataReader streamDataReader, AggregationProjection aggregationProjection)
        {
            object result = streamDataReader.GetValue(aggregationProjection.GetIndex());

            ShardingAssert.Else(null == result || result is IComparable, "Aggregation value must implements Comparable");
            return((IComparable)result);
        }
Example #2
0
 public MemoryQueryResultRow(IStreamDataReader streamDataReader)
 {
     _streamDataReader  = streamDataReader;
     var(data, columns) = Load(streamDataReader);
     _data    = data;
     _columns = columns;
 }
        private IDictionary <string, int> GetColumnLabelIndexMap(IStreamDataReader queryResult)
        {
            IDictionary <string, int> result = new Dictionary <string, int>(StringComparer.OrdinalIgnoreCase);

            for (int i = queryResult.ColumnCount - 1; i >= 0; i--)
            {
                result.Add(SqlUtil.GetExactlyValue(queryResult.GetColumnLabel(i)), i);
            }
            return(result);
        }
Example #4
0
        private List <object> GetGroupByValues(IStreamDataReader streamDataReader, ICollection <OrderByItem> groupByItems)
        {
            List <object> result = new List <object>(groupByItems.Count);

            foreach (var groupByItem in groupByItems)
            {
                result.Add(streamDataReader.GetValue(groupByItem.GetIndex()));
            }

            return(result);
        }
Example #5
0
        private IStreamDataReader Decorate(IStreamDataReader streamDataReader, ISqlCommandContext <ISqlCommand> sqlCommandContext)
        {
            IStreamDataReader result = null;

            foreach (var engineEntry in _engines)
            {
                if (engineEntry.Value is IResultDecoratorEngine <IBaseRule> resultDecoratorEngine)
                {
                    var resultDecorator = resultDecoratorEngine.NewInstance(_databaseType, _schemaMetaData, engineEntry.Key, _properties, sqlCommandContext);
                    result = null == result?resultDecorator.Decorate(streamDataReader, sqlCommandContext, _schemaMetaData) : resultDecorator.Decorate(result, sqlCommandContext, _schemaMetaData);
                }
            }
            return(result ?? streamDataReader);
        }
        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);
        }
Example #7
0
        /**
         * Process query results.
         *
         * @param queryResults query results
         * @param sqlStatementContext SQL statement context
         * @return merged result
         * @throws SQLException SQL exception
         */
        public IStreamDataReader Process(List <IStreamDataReader> streamDataReaders, ISqlCommandContext <ISqlCommand> sqlCommandContext)
        {
            var mergedResult         = Merge(streamDataReaders, sqlCommandContext);
            IStreamDataReader result = null;

            if (mergedResult != null)
            {
                result = Decorate(mergedResult, sqlCommandContext);
            }
            else
            {
                result = Decorate(streamDataReaders[0], sqlCommandContext);
            }
            return(result ?? new TransparentMergedDataReader(streamDataReaders[0]));
        }
Example #8
0
        private (object[] data, Dictionary <string, int> columns) Load(IStreamDataReader streamDataReader)
        {
            int columnCount = streamDataReader.ColumnCount;

            object[] result  = new object[columnCount];
            var      columns = new Dictionary <string, int>(columnCount);

            for (int i = 0; i < columnCount; i++)
            {
                result[i] = streamDataReader.GetValue(i);
                var columnName = streamDataReader.GetColumnName(i);
                columns[columnName] = i;
            }

            return(result, columns);
        }
        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 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);
            }
        }
Example #11
0
        //private readonly IDictionary<string, int> _columnLabelAndIndexMap;

        public ShardingDataReader(List <DbDataReader> dataReaders, IStreamDataReader streamDataReader, DbCommand command,
                                  ExecutionContext executionContext) : base(dataReaders, command, executionContext)
        {
            _streamDataReader = streamDataReader;
            //_columnLabelAndIndexMap = CreateColumnLabelAndIndexMap(dataReaders[0]);
        }
 public OrderByValue(IStreamDataReader streamDataReader, ICollection <OrderByItem> orderByItems, SelectCommandContext selectCommandContext, SchemaMetaData schemaMetaData)
 {
     this._streamDataReader        = streamDataReader;
     this.orderByItems             = orderByItems;
     this.orderValuesCaseSensitive = GetOrderValuesCaseSensitive(selectCommandContext, schemaMetaData);
 }
 public LimitDecoratorStreamDataReader(IStreamDataReader streamDataReader, PaginationContext pagination) : base(streamDataReader)
 {
     this.pagination = pagination;
     skipAll         = SkipOffset();
 }
 public IStreamDataReader Decorate(IStreamDataReader streamDataReader, ISqlCommandContext <ISqlCommand> sqlCommandContext,
                                   SchemaMetaData schemaMetaData)
 {
     return(new TransparentMergedDataReader(streamDataReader));
 }
 protected DecoratorStreamDataReader(IStreamDataReader streamDataReader)
 {
     StreamDataReader = streamDataReader;
 }
 public TransparentMergedDataReader(IStreamDataReader streamDataReader)
 {
     this._streamDataReader = streamDataReader;
 }
 public ZipParser(string zipFilePath, ICollection <string> extensionsToRead, IStreamDataReader dataReader)
 {
     this.archive          = ZipFile.OpenRead(zipFilePath);
     this.dataReader       = dataReader;
     this.extensionsToRead = extensionsToRead;
 }
        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);
            }
        }
Example #19
0
 public GroupByValue(IStreamDataReader streamDataReader, ICollection <OrderByItem> groupByItems)
 {
     _groupValues = GetGroupByValues(streamDataReader, groupByItems);
 }
Example #20
0
 public void SetCurrentStreamDataReader(IStreamDataReader streamDataReader)
 {
     _current = streamDataReader;
 }
 public ZipParser(string zipFilePath, ICollection<string> extensionsToRead, IStreamDataReader dataReader)
 {
     this.archive = ZipFile.OpenRead(zipFilePath);
     this.dataReader = dataReader;
     this.extensionsToRead = extensionsToRead;
 }
        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);
        }