Example #1
0
        public override SqlToken GenerateSqlToken(InsertCommandContext sqlCommandContext)
        {
            var result = FindPreviousSqlToken();

            ShardingAssert.ShouldBeNotNull(result, "not find PreviousSqlToken");
            var generatedKey = sqlCommandContext.GetGeneratedKeyContext();

            ShardingAssert.ShouldBeNotNull(generatedKey, "generatedKey is required");
            var generatedValues = generatedKey.GetGeneratedValues().Reverse().GetEnumerator();
            int count           = 0;

            foreach (var insertValueContext in sqlCommandContext.GetInsertValueContexts())
            {
                var insertValueToken = result.InsertValues[count];
                IDerivedSimpleExpressionSegment expressionSegment;
                if (IsToAddDerivedLiteralExpression(sqlCommandContext, count))
                {
                    expressionSegment = new DerivedLiteralExpressionSegment(generatedValues.Next());
                }
                else
                {
                    expressionSegment = new DerivedParameterMarkerExpressionSegment(insertValueContext.GetParametersCount(), string.Empty);
                }
                insertValueToken.GetValues().Add(expressionSegment);
                count++;
            }
            return(result);
        }
        public static object GetParameterValue(this List <object> parameters, ParameterMarkerExpressionSegment parameterMarkerExpressionSegment)
        {
            var parameter = parameters.Select(o => (DbParameter)o).FirstOrDefault(o => o.ParameterName.Equals(parameterMarkerExpressionSegment.GetParameterName()));

            ShardingAssert.ShouldBeNotNull(parameter, $"Sharding value cant find parameter name :[{parameterMarkerExpressionSegment.GetParameterName()}].");
            return(parameter.Value);
        }
        public override void RemoveAt(string parameterName)
        {
            ShardingAssert.ShouldBeNotNull(parameterName, nameof(parameterName));
            var indexOf = IndexOf(parameterName);

            RemoveAt(indexOf);
        }
Example #4
0
        private AggregationDistinctToken GenerateSQLToken(AggregationDistinctProjection projection)
        {
            ShardingAssert.ShouldBeNotNull(projection.GetAlias(), "alias is required");
            String derivedAlias = DerivedColumn.IsDerivedColumnName(projection.GetAlias()) ? projection.GetAlias() : null;

            return(new AggregationDistinctToken(projection.StartIndex, projection.StopIndex, projection.GetDistinctInnerExpression(), derivedAlias));
        }
        public override void Remove(object value)
        {
            ShardingAssert.ShouldBeNotNull(value, nameof(value));
            var parameter = CheckValue(value);

            RemoveAt(IndexOf(parameter));
        }
 public ComplexShardingStrategyConfiguration(string shardingColumns, IComplexKeysShardingAlgorithm <IComparable> shardingAlgorithm)
 {
     ShardingAssert.If(string.IsNullOrWhiteSpace(shardingColumns), "ShardingColumns is required.");
     ShardingAssert.ShouldBeNotNull(shardingAlgorithm, "ShardingAlgorithm is required.");
     this.ShardingColumns   = shardingColumns;
     this.ShardingAlgorithm = shardingAlgorithm;
 }
        public override int Add(object value)
        {
            ShardingAssert.ShouldBeNotNull(value, nameof(value));

            var parameter = CheckValue(value);

            parameter.ShardingParameters = this;
            bool hasName     = false;
            var  nameIsEmpty = string.IsNullOrEmpty(parameter.ParameterName);

            if (!nameIsEmpty)
            {
                hasName = _nameToIndex.TryGetValue(parameter.ParameterName, out var nameIndex);
                if (hasName && nameIndex != -1)
                {
                    throw new ShardingException($"Parameter '{parameter.ParameterName}' has already been defined.");
                }
            }

            if (!hasName)
            {
                if (!nameIsEmpty)
                {
                    _nameToIndex.Add(parameter.ParameterName, _parameters.Count);
                }
            }
            else
            {
                _nameToIndex[parameter.ParameterName] = _parameters.Count;
            }

            _parameters.Add(parameter);

            return(_parameters.Count - 1);
        }
Example #8
0
        public override SqlToken GenerateSqlToken(InsertCommandContext sqlCommandContext)
        {
            var insertColumnsSegment = sqlCommandContext.GetSqlCommand().InsertColumns;

            ShardingAssert.ShouldBeNotNull(insertColumnsSegment, "insertColumnsSegment is required");
            return(new UseDefaultInsertColumnsToken(insertColumnsSegment.GetStopIndex(), GetColumnNames(sqlCommandContext)));
        }
        public override bool Contains(object value)
        {
            ShardingAssert.ShouldBeNotNull(value, nameof(value));
            var parameter = CheckValue(value);

            return(_parameters.Contains(parameter));
        }
Example #10
0
        private IComparable GetValue(ParameterMarkerExpressionSegment expressionSegment, ParameterContext parameterContext)
        {
            object result = parameterContext.GetParameterValue(expressionSegment.GetParameterName());

            ShardingAssert.Else(result is IComparable, "Sharding value must implements IComparable.");
            return((IComparable)result);
        }
        public override int IndexOf(object value)
        {
            ShardingAssert.ShouldBeNotNull(value, nameof(value));
            var parameter = CheckValue(value);

            return(_parameters.IndexOf(parameter));
        }
Example #12
0
        private IComparable GetValue(LiteralExpressionSegment expressionSegment)
        {
            object result = expressionSegment.GetLiterals();

            ShardingAssert.Else(result is IComparable, "Sharding value must implements IComparable.");
            return((IComparable)result);
        }
Example #13
0
        public RouteContext Decorate(RouteContext routeContext, ShardingConnectorMetaData metaData, ShardingRule shardingRule,
                                     ConfigurationProperties properties)
        {
            var sqlStatementContext = routeContext.GetSqlCommandContext();
            // var tableNames = sqlStatementContext.GetTablesContext().GetTableNames();
            // if (!shardingRule.TableRules.Any(o => tableNames.Any(t => o.LogicTable.EqualsIgnoreCase(t))))
            // {
            //     return routeContext;
            // }
            var parameters = routeContext.GetParameterContext();

            ShardingCommandValidatorFactory.NewInstance(
                sqlStatementContext.GetSqlCommand())
            .IfPresent(validator => validator.Validate(shardingRule, sqlStatementContext.GetSqlCommand(), parameters));
            ShardingConditions shardingConditions = GetShardingConditions(parameters, sqlStatementContext, metaData.Schema, shardingRule);
            var needMergeShardingValues           = IsNeedMergeShardingValues(sqlStatementContext, shardingRule);

            if (needMergeShardingValues && sqlStatementContext.GetSqlCommand() is DMLCommand)
            {
                CheckSubQueryShardingValues(sqlStatementContext, shardingRule, shardingConditions);
                MergeShardingConditions(shardingConditions);
            }
            var         shardingRouteEngine = ShardingRouteEngineFactory.NewInstance(shardingRule, metaData, sqlStatementContext, shardingConditions, properties);
            RouteResult routeResult         = shardingRouteEngine.Route(shardingRule);

            if (needMergeShardingValues)
            {
                ShardingAssert.Else(1 == routeResult.GetRouteUnits().Count, "Must have one sharding with sub query.");
            }
            return(new RouteContext(sqlStatementContext, parameters, routeResult));
        }
        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);
        }
        public override void Insert(int index, object value)
        {
            ShardingAssert.ShouldBeNotNull(value, nameof(value));
            var parameter = CheckValue(value);

            if (!string.IsNullOrEmpty(parameter.ParameterName))
            {
                if (_nameToIndex.TryGetValue(parameter.ParameterName, out var i))
                {
                    throw new ShardingException($"Parameter '{parameter.ParameterName}' has already been defined.");
                }
            }

            if (index < _parameters.Count)
            {
                //将所有nameToIndex在插入index后面的都后移一位
                foreach (var pair in _nameToIndex)
                {
                    if (pair.Value >= index)
                    {
                        _nameToIndex[pair.Key] = pair.Value + 1;
                    }
                }
            }

            _parameters.Insert(index, parameter);
            _nameToIndex.Add(parameter.ParameterName, index);
        }
Example #16
0
        public SqlToken GenerateSqlToken(SelectCommandContext sqlCommandContext)
        {
            var pagination = sqlCommandContext.GetPaginationContext();

            ShardingAssert.ShouldBeNotNull(pagination.GetOffsetSegment(), "offset segment is required");
            return(new OffsetToken(pagination.GetOffsetSegment().GetStartIndex(), pagination.GetOffsetSegment().GetStopIndex(), pagination.GetRevisedOffset()));
        }
 public StandardShardingStrategy(StandardShardingStrategyConfiguration standardShardingStrategyConfig)
 {
     ShardingAssert.ShouldBeNotNull(standardShardingStrategyConfig.ShardingColumn, "Sharding column cannot be null.");
     ShardingAssert.ShouldBeNotNull(standardShardingStrategyConfig.PreciseShardingAlgorithm, "Sharding precise sharding algorithm cannot be null.");
     shardingColumn           = standardShardingStrategyConfig.ShardingColumn;
     preciseShardingAlgorithm = standardShardingStrategyConfig.PreciseShardingAlgorithm;
     rangeShardingAlgorithm   = standardShardingStrategyConfig.RangeShardingAlgorithm;
 }
Example #18
0
 public StandardShardingStrategyConfiguration(string shardingColumn, IPreciseShardingAlgorithm <IComparable> preciseShardingAlgorithm, IRangeShardingAlgorithm <IComparable> rangeShardingAlgorithm)
 {
     ShardingAssert.If(string.IsNullOrWhiteSpace(shardingColumn), "ShardingColumns is required.");
     ShardingAssert.ShouldBeNotNull(preciseShardingAlgorithm, "PreciseShardingAlgorithm is required.");
     this.ShardingColumn           = shardingColumn;
     this.PreciseShardingAlgorithm = preciseShardingAlgorithm;
     this.RangeShardingAlgorithm   = rangeShardingAlgorithm;
 }
 public ComplexShardingStrategy(ComplexShardingStrategyConfiguration complexShardingStrategyConfig)
 {
     ShardingAssert.ShouldBeNotNull(complexShardingStrategyConfig.ShardingColumns, "Sharding columns cannot be null.");
     ShardingAssert.ShouldBeNotNull(complexShardingStrategyConfig.ShardingAlgorithm, "Sharding algorithm cannot be null.");
     shardingColumns = new SortedSet <string>(StringComparer.OrdinalIgnoreCase);
     shardingColumns.AddAll(complexShardingStrategyConfig.ShardingColumns.Split(new [] { ',' }, StringSplitOptions.RemoveEmptyEntries));
     shardingAlgorithm = complexShardingStrategyConfig.ShardingAlgorithm;
 }
        /**
         * Get a new instance for {@code HintManager}.
         *
         * @return  {@code HintManager} instance
         */
        public static HintManager GetInstance()
        {
            ShardingAssert.Else(null == HINT_MANAGER_HOLDER.Value, "Hint has previous value, please clear first.");
            HintManager result = new HintManager();

            HINT_MANAGER_HOLDER.Value = result;
            return(result);
        }
Example #21
0
        public override SqlToken GenerateSqlToken(InsertCommandContext sqlCommandContext)
        {
            var generatedKey = sqlCommandContext.GetGeneratedKeyContext();

            ShardingAssert.ShouldBeNotNull(generatedKey, "generatedKey is required");
            var sqlSegment = sqlCommandContext.GetSqlCommand().InsertColumns;

            ShardingAssert.ShouldBeNotNull(sqlSegment, "sqlSegment is required");
            return(new GeneratedKeyInsertColumnToken(sqlSegment.GetStopIndex(), generatedKey.GetColumnName()));
        }
Example #22
0
        private List <String> GetColumnNames(InsertCommandContext insertCommandContext)
        {
            var generatedKey = insertCommandContext.GetGeneratedKeyContext();

            ShardingAssert.ShouldBeNotNull(generatedKey, "generatedKey is required");
            List <String> result = new List <string>(insertCommandContext.GetColumnNames());

            result.Remove(generatedKey.GetColumnName());
            result.Add(generatedKey.GetColumnName());
            return(result);
        }
        private ICollection <string> RouteDataSources(ShardingRule shardingRule, TableRule tableRule, List <IRouteValue> databaseShardingValues)
        {
            if (databaseShardingValues.IsEmpty())
            {
                return(tableRule.GetActualDatasourceNames());
            }
            ICollection <string> result = new HashSet <string>(shardingRule.GetDatabaseShardingStrategy(tableRule).DoSharding(tableRule.GetActualDatasourceNames(), databaseShardingValues, this.Properties));

            ShardingAssert.If(result.IsEmpty(), "no database route info");
            ShardingAssert.Else(tableRule.GetActualDatasourceNames().All(o => result.Contains(o)), $"Some routed data sources do not belong to configured data sources. routed data sources: `{result}`, configured data sources: `{tableRule.GetActualDatasourceNames()}`");

            return(result);
        }
Example #24
0
        private ICollection <string> GetTableNamesFromMetaData(DropIndexCommand dropIndexCommand)
        {
            ICollection <string> result = new LinkedList <string>();

            foreach (var index in dropIndexCommand.Indexes)
            {
                var tableName = FindLogicTableNameFromMetaData(index.Identifier.GetValue());
                ShardingAssert.ShouldBeNotNull(tableName, $"Cannot find index name `{index.Identifier.GetValue()}`.");
                result.Add(tableName);
            }

            return(result);
        }
        private List <IComparable> GetOrderValues()
        {
            var result = new List <IComparable>(orderByItems.Count);

            foreach (var orderByItem in orderByItems)
            {
                var value = _streamDataReader.GetValue(orderByItem.GetIndex());
                ShardingAssert.If(value == null || !(value is IComparable), "Order by value must implements Comparable");
                result.Add((IComparable)value);
            }

            return(result);
        }
        public override SqlToken GenerateSqlToken(InsertCommandContext sqlCommandContext)
        {
            var generatedKey = sqlCommandContext.GetGeneratedKeyContext();

            ShardingAssert.ShouldBeNotNull(generatedKey, "generatedKey is required");
            ShardingAssert.ShouldBeNotNull(sqlCommandContext.GetSqlCommand().SetAssignment, "setAssignment is required");
            int startIndex = sqlCommandContext.GetSqlCommand().SetAssignment.GetStopIndex() + 1;

            if (_parameterContext.IsEmpty())
            {
                return(new LiteralGeneratedKeyAssignmentToken(startIndex, generatedKey.GetColumnName(), generatedKey.GetGeneratedValues().LastOrDefault()));
            }
            return(new ParameterMarkerGeneratedKeyAssignmentToken(startIndex, generatedKey.GetColumnName()));
        }
        private ICollection <DataNode> RouteTables(ShardingRule shardingRule, TableRule tableRule, string routedDataSource, List <IRouteValue> tableShardingValues)
        {
            ICollection <string> availableTargetTables = tableRule.GetActualTableNames(routedDataSource);
            ICollection <string> routedTables          = new HashSet <string>(tableShardingValues.IsEmpty() ? availableTargetTables
                    : shardingRule.GetTableShardingStrategy(tableRule).DoSharding(availableTargetTables, tableShardingValues, this.Properties));

            ShardingAssert.If(routedTables.IsEmpty(), "no table route info");
            ICollection <DataNode> result = new LinkedList <DataNode>();

            foreach (var routedTable in routedTables)
            {
                result.Add(new DataNode(routedDataSource, routedTable));
            }
            return(result);
        }
        private IComparable GetRouteValue(ISimpleExpressionSegment expressionSegment, ParameterContext parameterContext)
        {
            object result;

            if (expressionSegment is ParameterMarkerExpressionSegment parameterMarkerExpressionSegment)
            {
                result = parameterContext.GetParameterValue(parameterMarkerExpressionSegment.GetParameterName());
            }
            else
            {
                result = ((LiteralExpressionSegment)expressionSegment).GetLiterals();
            }

            ShardingAssert.Else(result is IComparable, "Sharding value must implements IComparable.");
            return((IComparable)result);
        }
Example #29
0
 private void CheckSubQueryShardingValues(ISqlCommandContext <ISqlCommand> sqlStatementContext, ShardingRule shardingRule, ShardingConditions shardingConditions)
 {
     foreach (var tableName in sqlStatementContext.GetTablesContext().GetTableNames())
     {
         var tableRule = shardingRule.FindTableRule(tableName);
         if (tableRule != null && IsRoutingByHint(shardingRule, tableRule) &&
             HintManager.GetDatabaseShardingValues(tableName).Any() && HintManager.GetTableShardingValues(tableName).Any())
         {
             return;
         }
     }
     ShardingAssert.If(shardingConditions.Conditions.IsEmpty(), "Must have sharding column with subquery.");
     if (shardingConditions.Conditions.Count > 1)
     {
         ShardingAssert.Else(IsSameShardingCondition(shardingRule, shardingConditions), "Sharding value must same with subquery.");
     }
 }
Example #30
0
        private int Compare(MemoryQueryResultRow o1, MemoryQueryResultRow o2, ICollection <OrderByItem> orderByItems)
        {
            foreach (var orderByItem in orderByItems)
            {
                Object orderValue1 = o1.GetCell(orderByItem.GetIndex());
                ShardingAssert.Else(null == orderValue1 || orderValue1 is IComparable, "Order by value must implements Comparable");
                Object orderValue2 = o2.GetCell(orderByItem.GetIndex());
                ShardingAssert.Else(null == orderValue2 || orderValue2 is IComparable, "Order by value must implements Comparable");
                int result = CompareUtil.CompareTo((IComparable)orderValue1, (IComparable)orderValue2, orderByItem.GetSegment().GetOrderDirection(),
                                                   orderByItem.GetSegment().GetNullOrderDirection(), valueCaseSensitive[orderByItem.GetIndex()]);
                if (0 != result)
                {
                    return(result);
                }
            }

            return(0);
        }