数据库中间件Mycat源码解析（三）：Mycat的SQL解析和路由

最新推荐文章于 2024-05-14 19:18:11 发布
最新推荐文章于 2024-05-14 19:18:11 发布
阅读量1w 收藏 4
点赞数 2
分类专栏： JAVA学习 文章标签： JAVA 源码 mycat 分布式应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flashflight/article/details/52348323
版权

mycat对sql的解析分为两部分，一个是普通sql，另一个是PreparedStatment。

下面以解析普通sql为例分析（另一种方式大同小异），sql从客户端发过来后server接收后会调用FrontendCommandHandler的handle方法，这个方法会调用FrontendConnection的query方法，接着query方法会调用ServerQueryHandler的query方法，接着调用ServerConnection的execute方法。如下图所示：

public void execute(String sql, int type) {
		//连接状态检查
		if (this.isClosed()) {
			LOGGER.warn("ignore execute ,server connection is closed " + this);
			return;
		}
		// 事务状态检查
		if (txInterrupted) {
			writeErrMessage(ErrorCode.ER_YES,
					"Transaction error, need to rollback." + txInterrputMsg);
			return;
		}

		// 检查当前使用的DB
		String db = this.schema;
		boolean isDefault = true;
		if (db == null) {
			db = SchemaUtil.detectDefaultDb(sql, type);
			if (db == null) {
				writeErrMessage(ErrorCode.ERR_BAD_LOGICDB, "No MyCAT Database selected");
				return;
			}
			isDefault = false;
		}
		
		// 兼容PhpAdmin's, 支持对MySQL元数据的模拟返回
		 TODO: 2016/5/20 支持更多information_schema特性
		if (ServerParse.SELECT == type 
				&& db.equalsIgnoreCase("information_schema") ) {
			MysqlInformationSchemaHandler.handle(sql, this);
			return;
		}

		if (ServerParse.SELECT == type 
				&& sql.contains("mysql") 
				&& sql.contains("proc")) {
			
			SchemaUtil.SchemaInfo schemaInfo = SchemaUtil.parseSchema(sql);
			if (schemaInfo != null 
					&& "mysql".equalsIgnoreCase(schemaInfo.schema)
					&& "proc".equalsIgnoreCase(schemaInfo.table)) {
				
				// 兼容MySQLWorkbench
				MysqlProcHandler.handle(sql, this);
				return;
			}
		}
		
		SchemaConfig schema = MycatServer.getInstance().getConfig().getSchemas().get(db);
		if (schema == null) {
			writeErrMessage(ErrorCode.ERR_BAD_LOGICDB,
					"Unknown MyCAT Database '" + db + "'");
			return;
		}

		//fix navicat   SELECT STATE AS `State`, ROUND(SUM(DURATION),7) AS `Duration`, CONCAT(ROUND(SUM(DURATION)/*100,3), '%') AS `Percentage` FROM INFORMATION_SCHEMA.PROFILING WHERE QUERY_ID= GROUP BY STATE ORDER BY SEQ
		if(ServerParse.SELECT == type &&sql.contains(" INFORMATION_SCHEMA.PROFILING ")&&sql.contains("CONCAT(ROUND(SUM(DURATION)/*100,3)"))
		{
			InformationSchemaProfiling.response(this);
			return;
		}
		
		/* 当已经设置默认schema时，可以通过在sql中指定其它schema的方式执行
		 * 相关sql，已经在mysql客户端中验证。
		 * 所以在此处增加关于sql中指定Schema方式的支持。
		 */
		if (isDefault && schema.isCheckSQLSchema() && isNormalSql(type)) {
			SchemaUtil.SchemaInfo schemaInfo = SchemaUtil.parseSchema(sql);
			if (schemaInfo != null && schemaInfo.schema != null && !schemaInfo.schema.equals(db)) {
				SchemaConfig schemaConfig = MycatServer.getInstance().getConfig().getSchemas().get(schemaInfo.schema);
				if (schemaConfig != null)
					schema = schemaConfig;
			}
		}

		routeEndExecuteSQL(sql, type, schema);

	}
最后有个routeEndExecuteSQL方法，它会首先调用RouteService的route方法先进行路由，然后调用HintSQLHandler的route方法，这个方法里调用RouteStrategy的route方法，这里使用了一个策略模式，包含下面几种sql类型，不同类型使用不同策略。 
public final class ServerParse {

	public static final int OTHER = -1;
	public static final int BEGIN = 1;
	public static final int COMMIT = 2;
	public static final int DELETE = 3;
	public static final int INSERT = 4;
	public static final int REPLACE = 5;
	public static final int ROLLBACK = 6;
	public static final int SELECT = 7;
	public static final int SET = 8;
	public static final int SHOW = 9;
	public static final int START = 10;
	public static final int UPDATE = 11;
	public static final int KILL = 12;
	public static final int SAVEPOINT = 13;
	public static final int USE = 14;
	public static final int EXPLAIN = 15;
	public static final int EXPLAIN2 = 151;
	public static final int KILL_QUERY = 16;
	public static final int HELP = 17;
	public static final int MYSQL_CMD_COMMENT = 18;
	public static final int MYSQL_COMMENT = 19;
	public static final int CALL = 20;
	public static final int DESCRIBE = 21;
    public static final int LOAD_DATA_INFILE_SQL = 99;
    public static final int DDL = 100;

使用不同的路由方法是在routeNormalSqlWithAST中决定的， 

public RouteResultset routeNormalSqlWithAST(SchemaConfig schema,
			String stmt, RouteResultset rrs, String charset,
			LayerCachePool cachePool) throws SQLNonTransientException {
		
		/**
		 *  只有mysql时只支持mysql语法
		 */
		SQLStatementParser parser = null;
		if (schema.isNeedSupportMultiDBType()) {
			parser = new MycatStatementParser(stmt);
		} else {
			parser = new MySqlStatementParser(stmt); 
		}

		MycatSchemaStatVisitor visitor = null;
		SQLStatement statement;
		
		/**
		 * 解析出现问题统一抛SQL语法错误
		 */
		try {
			statement = parser.parseStatement();
            visitor = new MycatSchemaStatVisitor();
		} catch (Exception t) {
	        LOGGER.error("DruidMycatRouteStrategyError", t);
			throw new SQLSyntaxErrorException(t);
		}

		/**
		 * 检验unsupported statement
		 */
		checkUnSupportedStatement(statement);


		DruidParser druidParser = DruidParserFactory.create(schema, statement, visitor);
		druidParser.parser(schema, rrs, statement, stmt,cachePool,visitor);

		/**
		 * DruidParser 解析过程中已完成了路由的直接返回
		 */
		if ( rrs.isFinishedRoute() ) {
			return rrs;
		}
		
		/**
		 * 没有from的select语句或其他
		 */
        DruidShardingParseInfo ctx=  druidParser.getCtx() ;
        if((ctx.getTables() == null || ctx.getTables().size() == 0)&&(ctx.getTableAliasMap()==null||ctx.getTableAliasMap().isEmpty()))
        {
		    return RouterUtil.routeToSingleNode(rrs, schema.getRandomDataNode(), druidParser.getCtx().getSql());
		}

		if(druidParser.getCtx().getRouteCalculateUnits().size() == 0) {
			RouteCalculateUnit routeCalculateUnit = new RouteCalculateUnit();
			druidParser.getCtx().addRouteCalculateUnit(routeCalculateUnit);
		}
		
		SortedSet<RouteResultsetNode> nodeSet = new TreeSet<RouteResultsetNode>();
		for(RouteCalculateUnit unit: druidParser.getCtx().getRouteCalculateUnits()) {
			RouteResultset rrsTmp = RouterUtil.tryRouteForTables(schema, druidParser.getCtx(), unit, rrs, isSelect(statement), cachePool);
			if(rrsTmp != null) {
				for(RouteResultsetNode node :rrsTmp.getNodes()) {
					nodeSet.add(node);
				}
			}
		}
		
		RouteResultsetNode[] nodes = new RouteResultsetNode[nodeSet.size()];
		int i = 0;
		for (Iterator<RouteResultsetNode> iterator = nodeSet.iterator(); iterator.hasNext();) {
			nodes[i] = iterator.next();
			i++;
		}		
		rrs.setNodes(nodes);		
		
		//分表
		/**
		 *  subTables="t_order$1-2,t_order3"
		 *目前分表 1.6 开始支持 幵丏 dataNode 在分表条件下只能配置一个，分表条件下不支持join。
		 */
		if(rrs.isDistTable()){
			return this.routeDisTable(statement,rrs);
		}
		
		return rrs;
	}
它使用druid做数据库连接池，支持分库分表，下面我们以多个表的分库分表路由策略为例子进行分析。 

public static void findRouteWithcConditionsForTables(SchemaConfig schema, RouteResultset rrs,
			Map<String, Map<String, Set<ColumnRoutePair>>> tablesAndConditions,
			Map<String, Set<String>> tablesRouteMap, String sql, LayerCachePool cachePool, boolean isSelect)
			throws SQLNonTransientException {
		
		//为分库表找路由
		for(Map.Entry<String, Map<String, Set<ColumnRoutePair>>> entry : tablesAndConditions.entrySet()) {
			String tableName = entry.getKey().toUpperCase();
			TableConfig tableConfig = schema.getTables().get(tableName);
			if(tableConfig == null) {
				String msg = "can't find table define in schema "
						+ tableName + " schema:" + schema.getName();
				LOGGER.warn(msg);
				throw new SQLNonTransientException(msg);
			}
			if(tableConfig.getDistTables()!=null && tableConfig.getDistTables().size()>0){
				routeToDistTableNode(tableName,schema,rrs,sql, tablesAndConditions, cachePool,isSelect);
			}
			//全局表或者不分库的表略过（全局表后面再计算）
			if(tableConfig.isGlobalTable() || schema.getTables().get(tableName).getDataNodes().size() == 1) {
				continue;
			} else {//非全局表：分库表、childTable、其他
				Map<String, Set<ColumnRoutePair>> columnsMap = entry.getValue();
				String joinKey = tableConfig.getJoinKey();
				String partionCol = tableConfig.getPartitionColumn();
				String primaryKey = tableConfig.getPrimaryKey();
				boolean isFoundPartitionValue = partionCol != null && entry.getValue().get(partionCol) != null;
                boolean isLoadData=false;
                if (LOGGER.isDebugEnabled()
						&& sql.startsWith(LoadData.loadDataHint)||rrs.isLoadData()) {
                     //由于load data一次会计算很多路由数据，如果输出此日志会极大降低load data的性能
                         isLoadData=true;
                }
				if(entry.getValue().get(primaryKey) != null && entry.getValue().size() == 1&&!isLoadData)
                {//主键查找
					// try by primary key if found in cache
					Set<ColumnRoutePair> primaryKeyPairs = entry.getValue().get(primaryKey);
					if (primaryKeyPairs != null) {
						if (LOGGER.isDebugEnabled()) {
                                 LOGGER.debug("try to find cache by primary key ");
						}
						String tableKey = schema.getName() + '_' + tableName;
						boolean allFound = true;
						for (ColumnRoutePair pair : primaryKeyPairs) {//可能id in(1,2,3)多主键
							String cacheKey = pair.colValue;
							String dataNode = (String) cachePool.get(tableKey, cacheKey);
							if (dataNode == null) {
								allFound = false;
								continue;
							} else {
								if(tablesRouteMap.get(tableName) == null) {
									tablesRouteMap.put(tableName, new HashSet<String>());
								}
								tablesRouteMap.get(tableName).add(dataNode);
								continue;
							}
						}
						if (!allFound) {
							// need cache primary key ->datanode relation
							if (isSelect && tableConfig.getPrimaryKey() != null) {
								rrs.setPrimaryKey(tableKey + '.' + tableConfig.getPrimaryKey());
							}
						} else {//主键缓存中找到了就执行循环的下一轮
							continue;
						}
					}
				}
				if (isFoundPartitionValue) {//分库表
					Set<ColumnRoutePair> partitionValue = columnsMap.get(partionCol);
					if(partitionValue == null || partitionValue.size() == 0) {
						if(tablesRouteMap.get(tableName) == null) {
							tablesRouteMap.put(tableName, new HashSet<String>());
						}
						tablesRouteMap.get(tableName).addAll(tableConfig.getDataNodes());
					} else {
						for(ColumnRoutePair pair : partitionValue) {
							if(pair.colValue != null) {
								Integer nodeIndex = tableConfig.getRule().getRuleAlgorithm().calculate(pair.colValue);
								if(nodeIndex == null) {
									String msg = "can't find any valid datanode :" + tableConfig.getName()
											+ " -> " + tableConfig.getPartitionColumn() + " -> " + pair.colValue;
									LOGGER.warn(msg);
									throw new SQLNonTransientException(msg);
								}

								ArrayList<String> dataNodes = tableConfig.getDataNodes();
								String node;
								if (nodeIndex >=0 && nodeIndex < dataNodes.size()) {
									node = dataNodes.get(nodeIndex);
								} else {
									node = null;
									String msg = "Can't find a valid data node for specified node index :"
											+ tableConfig.getName() + " -> " + tableConfig.getPartitionColumn()
											+ " -> " + pair.colValue + " -> " + "Index : " + nodeIndex;
									LOGGER.warn(msg);
									throw new SQLNonTransientException(msg);
								}
								if(node != null) {
									if(tablesRouteMap.get(tableName) == null) {
										tablesRouteMap.put(tableName, new HashSet<String>());
									}
									tablesRouteMap.get(tableName).add(node);
								}
							}
							if(pair.rangeValue != null) {
								Integer[] nodeIndexs = tableConfig.getRule().getRuleAlgorithm()
										.calculateRange(pair.rangeValue.beginValue.toString(), pair.rangeValue.endValue.toString());
								ArrayList<String> dataNodes = tableConfig.getDataNodes();
								String node;
								for(Integer idx : nodeIndexs) {
									if (idx >= 0 && idx < dataNodes.size()) {
										node = dataNodes.get(idx);
									} else {
										String msg = "Can't find valid data node(s) for some of specified node indexes :"
												+ tableConfig.getName() + " -> " + tableConfig.getPartitionColumn();
										LOGGER.warn(msg);
										throw new SQLNonTransientException(msg);
									}
									if(node != null) {
										if(tablesRouteMap.get(tableName) == null) {
											tablesRouteMap.put(tableName, new HashSet<String>());
										}
										tablesRouteMap.get(tableName).add(node);

									}
								}
							}
						}
					}
				} else if(joinKey != null && columnsMap.get(joinKey) != null && columnsMap.get(joinKey).size() != 0) {//childTable  (如果是select 语句的父子表join)之前要找到root table,将childTable移除,只留下root table
					Set<ColumnRoutePair> joinKeyValue = columnsMap.get(joinKey);
					
					Set<String> dataNodeSet = ruleByJoinValueCalculate(rrs, tableConfig, joinKeyValue);

					if (dataNodeSet.isEmpty()) {
						throw new SQLNonTransientException(
								"parent key can't find any valid datanode ");
					}
					if (LOGGER.isDebugEnabled()) {
						LOGGER.debug("found partion nodes (using parent partion rule directly) for child table to update  "
								+ Arrays.toString(dataNodeSet.toArray()) + " sql :" + sql);
					}
					if (dataNodeSet.size() > 1) {
						routeToMultiNode(rrs.isCacheAble(), rrs, dataNodeSet, sql);
						rrs.setFinishedRoute(true);
						return;
					} else {
						rrs.setCacheAble(true);
						routeToSingleNode(rrs, dataNodeSet.iterator().next(), sql);
						return;
					}

				} else {
					//没找到拆分字段，该表的所有节点都路由
					if(tablesRouteMap.get(tableName) == null) {
						tablesRouteMap.put(tableName, new HashSet<String>());
					}
					tablesRouteMap.get(tableName).addAll(tableConfig.getDataNodes());
				}
			}
		}
	}
mycat会先找主键（支持多主键），根据主键去找不同的node节点，然后在不同的node分别执行sql，这样它就获取了sql的路由表，所谓的路由表就是查找表存在于哪些节点中。这个如果是在依据主键分库分表（同时存在多种分片类型如下图所示）的情况下主要通过分析sql中的存在的表名和主键的键值在schema配置中通过算法（RuleAlgorithm）查找的（如果没有主键范围就路由到所有节点），找到节点后，才具体去执行sql。 

PartitionByDate
PartitionByFileMap
PartitionByHashMod
PartitionByHotDate
PartitionByJumpConsistentHash
PartitionByLong
PartitionByMod
PartitionByMonth
PartitionByMurmurHash
PartitionByPattern
PartitionByPrefixPattern
PartitionByRangeDateHash
PartitionByRangeMod
PartitionByString
PartitionDirectBySubString

在上面提到的routeEndExecuteSQL方法中找到路由节点后它会调用NonBlockingSession的execute方法，它分为单节点模式和多节点模式，下面以多节点模式为例，在这种情况下它会调用MultiNodeQueryHandler的execute方法。

public void execute() throws Exception {
		final ReentrantLock lock = this.lock;
		lock.lock();
		try {
			this.reset(rrs.getNodes().length);
			this.fieldsReturned = false;
			this.affectedRows = 0L;
			this.insertId = 0L;
		} finally {
			lock.unlock();
		}
		MycatConfig conf = MycatServer.getInstance().getConfig();
		startTime = System.currentTimeMillis();
		LOGGER.debug("rrs.getRunOnSlave()-" + rrs.getRunOnSlave());
		for (final RouteResultsetNode node : rrs.getNodes()) {
			BackendConnection conn = session.getTarget(node);
			if (session.tryExistsCon(conn, node)) {
				LOGGER.debug("node.getRunOnSlave()-" + node.getRunOnSlave());
				node.setRunOnSlave(rrs.getRunOnSlave());	// 实现 master/slave注解
				LOGGER.debug("node.getRunOnSlave()-" + node.getRunOnSlave());
				_execute(conn, node);
			} else {
				// create new connection
				LOGGER.debug("node.getRunOnSlave()1-" + node.getRunOnSlave());
				node.setRunOnSlave(rrs.getRunOnSlave());	// 实现 master/slave注解
				LOGGER.debug("node.getRunOnSlave()2-" + node.getRunOnSlave());
				PhysicalDBNode dn = conf.getDataNodes().get(node.getName());
				dn.getConnection(dn.getDatabase(), autocommit, node, this, node);
				// 注意该方法不仅仅是获取连接，获取新连接成功之后，会通过层层回调，最后回调到本类 的connectionAcquired
				// 这是通过 上面方法的 this 参数的层层传递完成的。
				// connectionAcquired 进行执行操作:
				// session.bindConnection(node, conn);
				// _execute(conn, node);
			}

		}
	}

到此优化后的sql被发给路由结果中的各个节点执行。



闲庭细步
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
三、MyCat 客户端 SQL 请求执行流程
LZN的博客
09-30 767
RW#run 轮询注册队列中是否有 AbstractConnection，若存在且为读事件则调用 AbstractConnection#asynRead 异步读取数据，实际处理逻辑见 NIOSocketWR#asynRead NIOSocketWR#asynRead 从 前端连接的 channel 中读取数据，并且保存到对应 AbstractConnection 的 readBuffer 中，之后调用 AbstractConnection#onReadData 处理读取到的数据 @Override...
Mycat之数据库分片（时间分片,按月份分片）-yellowcong
01-18 5708
取模分片，简单来讲，根据数据库的主键和存储的节点数进行取模操作，然后根据取模的结果，将数据存放到对应的节点中，取模分表，可以将数据均匀的分配到各个库中。实现的步骤：1、创建数据库，2、配置schema.xml文件，3、配置server.xml，4、添加rule.xml。这种方式。 数据库时间分片，有个问题，就比如按照月份分片，我只能分片这一年的数据，如果来年了，我还需要自己手动来创建一个表，然后在做
2024年最全源码分析mycat1，互联网大厂面试题库
最新发布
2401_84437095的博客
05-14 736
如果你打算靠自己摸索自学，那么你首先要了解学习前端的基本大纲，这是你将要学习的主要内容，理解以及掌握好这些内容，便可以找到一份初级的前端开发工作。你还需要有一套完整的前端学习教程，作为初学者最好的方式就是看视频教程学习，初学者容易理解接受。不要选择买书学习，这样的方式没有几个人能学会，基本都是看不下去书，也看不懂书。如果喜欢看书的学弟，可以买一些经典的书籍作为辅助即可，主要还是以看教程为主。每天抽出固定几个小时学习，做好长期学习的准备。
Mycat查询时出现：Error Code: 1064. can't find any valid datanode
weixin_34334744的博客
12-28 722
说明：这个错误是查询时条件字段超过了范围导致的。 解释： 为什么会出现范围问题？ 一般在MySQL查询时不会因为字段的值超过了范围而导致的，但是在Mycat中却不是这样认为的，Mycat是由于采用的分片的机制，而每个分片采用枚举的算法，然后根据索引进行分片，然后这些枚举会定义一定的范围，所以当这个查询的值大于这个范围就出现找不到的情况了。 这个解释好理解，但不一定正确，只是做为一个参考。 ...
MySQL数据库优化(一)
李双喆
03-19 2281
1. 数据库优化的目的      1）数据库慢速查询，解决界面内容加载不出来；    2）增加数据库的稳定性； 2. SQL工具 2.1 慢查日志     慢查日志呢就是MySQL日志查询比较慢的SQL语句的日志。详细的记录了所有的超过某一时间的SQL语句。    1）慢查日志的开启     首先查看慢查日志是否开启：show VARIABLES like '%slow%'，
mycat配置文件详解 安装指南
snowpay的博客
07-07 1649
mycat安装步骤linux下 安装jdk   mysql   安装mycat   官网下载最新的mycat版本   http://dl.mycat.io/ 解压mycat文件到自己想要的目录 创建mycat用户   useradd mycat        ;  psswd mycat 把mycat文件夹的所属变为mycat用户      chown -R mycat:mycat m
数据库中间件mycat
09-06
数据库中间件是一种位于应用程序和数据库之间的软件层，可以帮助应用程序和数据库之间的交互，提供数据库路由、读写分离、连接数复用、数据库扩展等功能。数据库中间件可以帮助用户解决单个表数据量太大、单个库数据...
数据库中间件MyCat的介绍
09-09
【数据库中间件MyCat介绍】 MyCat是一款开源的分布式数据库系统，它作为数据库中间件，实现了MySQL协议，允许前端用户将其视为一个数据库代理，而实际上它可以在后端连接多个MySQL服务器或其他主流数据库，如SQL ...
Mycat路由新解析器选型分析与结果.docx
07-30
Mycat，作为一个分布式数据库中间件，其路由解析器的性能和功能对于整个系统来说至关重要。一直以来，Mycat依赖于fdb parser，一个源于Apache Derby的解析器，该解析器在FoundationDB项目中被采用。然而，fdb parser...
MySQL分布式数据库中间件Mycat性能调优指南
05-20
MySQL分布式数据库中间件Mycat是一款广泛应用于大数据处理和高并发场景的重要工具，它通过将数据分布到多个物理节点上，实现了数据的水平扩展。在实际应用中，Mycat的性能调优对于系统的整体效率至关重要。本指南将...
Mycat2数据库中间件-其他
06-11
MyCAT还是一种新型的数据库，它看起来像是与内存缓存技术，NoSQL技术和HDFS大数据集成的SQL Server。作为一种新型的现代企业数据库产品，MyCAT与传统的数据库和新的分布式数据仓库相结合。总之，MyCAT是一种全新的...
Mycat--分片规则
IT利刃出鞘的博客
04-05 609
其他网址 Mycat分片规则详解 - 小小小小小小鱼 - 博客园 另见：《Mycat权威指南》=> 入门篇=>10.5 Mycat 常用的分片规则 1、分片枚举 通过在配置文件中配置可能的枚举 id，自己配置分片，本规则适用于特定的场景，比如有些业务需要按照省份或区县来做保存，而全国省份区县固定的，这类业务使用本条规则，配置如下： <tableRul...
Mycat源码篇 : Mycat sql解析模块分析
CrazyPig的技术博客
10-06 7051
mycat sql解析模块是mycat实现sql路由模块和sql结果集后处理模块的基础，在mycat的几大模块里面占据相当重要的位置。这篇文章首先简单介绍mycat里面sql解析模块的作用，后面结合部分源码来看这个模块的功能。
Mycat1.5卡死问题
K-Darker的专栏
05-28 1636
一、Mycat执行sql卡死执行sql 语句 and data_type ='xxx' ORDER BY created_time desc x 执行这种sql导致Reactor线程卡死,cpu爆满二、Mycat进程栈日志"$_NIOREACTOR-0-RW" #18 prio=5 os_prio=0 tid=0x000000001b002000 nid=0x2110 runna ble [0x0...
MyCat 笔记-2017年12月22日
天地为炉
12-22 1045
MyCat 笔记标签（空格分隔）： 数据库 mycatMyCat 笔记 一些概念 配置文件说明 全局主键及自增长主键 全局主键 自增长主键 分片规则中需要注意的点 自然月分片 下面是一些总结的知识点 mycat管理命令 mycat读写分离 基于mysql master-slave架构的读写分离 mycat故障切换 mycat优化 mysql优化 mycat源码解析 路由判断 本文写作用的mycat版
mycat 用Jconsole监控mycat压测的各种性能曲线
热门推荐
csdn's blog
07-17 1万+
1，最方便的Mycat监控工具—Jconsole JDK自带，Windows下图形界面，监控分析Java程序，进入jdk安装目录的bin下面，C:\Program Files\Java\jdk1.7.0_15\bin，双击jconsole.exe打开。 2，去查看后台jmx启动的端口 查看jmx进程号： [root@oracle_standby conf]# ps -eaf|...
php修改mysql数据库栈溢出,记一次mycat的问题检查-栈溢出
weixin_39553272的博客
04-13 289
注：以下问题为去年的问题，记录在自己的为知笔记中，拿出来分享下。现象：运行了两年的mycat，突然变得十分不稳定。4个mycat实例，在运行一段时间(有时几个小时，有时1-2天)总会出现偶尔无法连接等问题，监控程序经常会报错。日志：查看mycat.log日志中，没有任何的信息。在console.log中找到stackoverflowerror，但是只有1条这样的错误，和检测不能连接的时间并不相同。...
Mycat之数据库分片（自定义范围分片）-yellowcong
01-16 4581
Mycat切片规则挺多的，我就简单讲讲一些吧，这个是自定义范围分片，简单来将，就是我有两个数据库，a放多少条记录，b放多少调数据。这样就实现了分片的操作。实现步骤：1、创建数据库。2、配置schemal.xml，3、配置service.xml,4、修改rule.xml，设置默认插入的节点、5、修改auto-sharding-long.txt,设置置分片范围。 创建数据库这个地方我主键采用的是本地时间
你作为一个java领域的专家，请完成以下任务：使用MyCat作为分布式数据库中间件需要注意什么问题？以及怎么解决？
09-01
总之，使用MyCat作为分布式数据库中间件，需要注意数据一致性、分片规则设计、数据迁移和扩容、高可用性和容错性以及监控和调优等问题，并采取相应的解决方案来保证系统的稳定性和性能。 ### 回答3： 使用MyCat...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值