public ShardingComplexRoutingEngine(ICollection <string> logicTables, ISqlCommandContext <ISqlCommand> sqlStatementContext, ShardingConditions shardingConditions, ConfigurationProperties properties)
 {
     this.logicTables         = logicTables;
     this.sqlStatementContext = sqlStatementContext;
     this.shardingConditions  = shardingConditions;
     this.properties          = properties;
 }
Example #2
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));
        }
Example #3
0
 private void MergeShardingConditions(ShardingConditions shardingConditions)
 {
     if (shardingConditions.Conditions.Count > 1)
     {
         ShardingCondition shardingCondition =
             shardingConditions.Conditions[shardingConditions.Conditions.Count - 1];
         shardingConditions.Conditions.RemoveAt(shardingConditions.Conditions.Count - 1);
         shardingConditions.Conditions.Clear();
         shardingConditions.Conditions.Add(shardingCondition);
     }
 }
        private static IShardingRouteEngine GetShardingRoutingEngine(ShardingRule shardingRule, ISqlCommandContext <ISqlCommand> sqlCommandContext,
                                                                     ShardingConditions shardingConditions, ICollection <String> tableNames, ConfigurationProperties properties)
        {
            ICollection <String> shardingTableNames = shardingRule.GetShardingLogicTableNames(tableNames);

            if (1 == shardingTableNames.Count || shardingRule.IsAllBindingTables(shardingTableNames))
            {
                return(new ShardingStandardRoutingEngine(shardingTableNames.First(), sqlCommandContext, shardingConditions, properties));
            }
            // TODO config for cartesian set
            return(new ShardingComplexRoutingEngine(tableNames, sqlCommandContext, shardingConditions, properties));
        }
Example #5
0
        private bool IsSameShardingCondition(ShardingRule shardingRule, ShardingConditions shardingConditions)
        {
            ShardingCondition example = shardingConditions.Conditions.Last();

            shardingConditions.Conditions.RemoveAt(shardingConditions.Conditions.Count - 1);
            foreach (var condition in shardingConditions.Conditions)
            {
                if (!IsSameShardingCondition(shardingRule, example, condition))
                {
                    return(false);
                }
            }
            return(true);
        }
        public static IShardingRouteEngine NewInstance(ShardingRule shardingRule,
                                                       ShardingConnectorMetaData metaData, ISqlCommandContext <ISqlCommand> sqlCommandContext,
                                                       ShardingConditions shardingConditions, ConfigurationProperties properties)
        {
            var sqlStatement = sqlCommandContext.GetSqlCommand();
            ICollection <String> tableNames = sqlCommandContext.GetTablesContext().GetTableNames();

            if (sqlStatement is TCLCommand)
            {
                return(new ShardingDatabaseBroadcastRoutingEngine());
            }
            if (sqlStatement is DDLCommand)
            {
                return(new ShardingTableBroadcastRoutingEngine(metaData.Schema, sqlCommandContext));
            }
            if (sqlStatement is DALCommand)
            {
                return(GetDALRoutingEngine(shardingRule, sqlStatement, tableNames));
            }
            if (sqlStatement is DCLCommand)
            {
                return(GetDCLRoutingEngine(sqlCommandContext, metaData));
            }
            if (shardingRule.IsAllInDefaultDataSource(tableNames))
            {
                return(new ShardingDefaultDatabaseRoutingEngine(tableNames));
            }
            if (shardingRule.IsAllBroadcastTables(tableNames))
            {
                if (sqlStatement is SelectCommand)
                {
                    return(new ShardingUnicastRoutingEngine(tableNames));
                }
                return(new ShardingDatabaseBroadcastRoutingEngine());
            }
            if (sqlCommandContext.GetSqlCommand() is DMLCommand && tableNames.IsEmpty() && shardingRule.HasDefaultDataSourceName())
            {
                return(new ShardingDefaultDatabaseRoutingEngine(tableNames));
            }
            if (sqlCommandContext.GetSqlCommand() is DMLCommand && shardingConditions.IsAlwaysFalse() || tableNames.IsEmpty() || !shardingRule.TableRuleExists(tableNames))
            {
                return(new ShardingUnicastRoutingEngine(tableNames));
            }
            return(GetShardingRoutingEngine(shardingRule, sqlCommandContext, shardingConditions, tableNames, properties));
        }
 public ShardingStandardRoutingEngine(string logicTableName, ISqlCommandContext <ISqlCommand> sqlCommandContext, ShardingConditions shardingConditions, ConfigurationProperties properties)
 {
     this.LogicTableName     = logicTableName;
     this.SqlCommandContext  = sqlCommandContext;
     this.ShardingConditions = shardingConditions;
     this.Properties         = properties;
 }
Example #8
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.");
     }
 }