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);
}
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);
}
/**
* 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);
}
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 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);
}
