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); }
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); }
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)); }
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)); }
private IComparable GetValue(LiteralExpressionSegment expressionSegment) { object result = expressionSegment.GetLiterals(); ShardingAssert.Else(result is IComparable, "Sharding value must implements IComparable."); return((IComparable)result); }
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); }
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; }
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); }
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())); }
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); }
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); }
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."); } }
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); }