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 override bool Contains(object value)
{
ShardingAssert.ShouldBeNotNull(value, nameof(value));
var parameter = CheckValue(value);
return(_parameters.Contains(parameter));
}
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 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 IndexOf(object value)
{
ShardingAssert.ShouldBeNotNull(value, nameof(value));
var parameter = CheckValue(value);
return(_parameters.IndexOf(parameter));
}
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 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;
}
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> 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);
}
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()));
}
public void Rewrite(IParameterBuilder parameterBuilder, ISqlCommandContext <ISqlCommand> sqlCommandContext, ParameterContext parameterContext)
{
var insertCommandContext = (InsertCommandContext)sqlCommandContext;
ShardingAssert.ShouldBeNotNull(insertCommandContext.GetGeneratedKeyContext(), "insertCommandContext.GetGeneratedKeyContext is required");
((GroupedParameterBuilder)parameterBuilder).SetDerivedColumnName(insertCommandContext.GetGeneratedKeyContext().GetColumnName());
var generatedValues = insertCommandContext.GetGeneratedKeyContext().GetGeneratedValues().Reverse().GetEnumerator();
int count = 0;
int parametersCount = 0;
foreach (var groupedParameter in insertCommandContext.GetGroupedParameters())
{
parametersCount += insertCommandContext.GetInsertValueContexts()[count].GetParametersCount();
var generatedValue = generatedValues.Next();
if (!groupedParameter.IsEmpty())
{
((GroupedParameterBuilder)parameterBuilder).GetParameterBuilders()[count].AddAddedParameters(parametersCount, new List <object>()
{
generatedValue
});
}
count++;
}
}
public HintShardingStrategy(HintShardingStrategyConfiguration hintShardingStrategyConfig)
{
ShardingAssert.ShouldBeNotNull(hintShardingStrategyConfig.ShardingAlgorithm, "Sharding algorithm cannot be null.");
ShardingColumns = new SortedSet <string>(StringComparer.OrdinalIgnoreCase);
ShardingAlgorithm = hintShardingStrategyConfig.ShardingAlgorithm;
}
public HintShardingStrategyConfiguration(IHintShardingAlgorithm <IComparable> shardingAlgorithm)
{
ShardingAssert.ShouldBeNotNull(shardingAlgorithm, "ShardingAlgorithm is required.");
this.ShardingAlgorithm = shardingAlgorithm;
}
