mycat2伪分布式分库分表——以ml-latest数据集为例

最新推荐文章于 2024-05-27 10:38:40 发布
最新推荐文章于 2024-05-27 10:38:40 发布
阅读量1k 收藏 2
点赞数
文章标签： 分布式 python mycat mysql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42856273/article/details/122253071
版权

mycat2分库分表实验——以ml-latest数据集为例

注：users.csv非ml-latest数据集中的内容，是任课老师便于前端展示而随机生成的文件

由于ubuntu20.04最低支持mysql8，而mycat1与后端flask相连会因为utf8mb4的编码和mysql8废弃的方法导致无法解决的问题，遂尝试使用最新适配mysql8的mycat2。以下是本人的野人献曝。

数据处理总体思想：扔掉冗余数据

  1. movieId处理
    提取出tag、link、movie表共同的movieId（求交集），并且把tag、link、movie表的movieId替换为新的movieId，最后扔掉存在空值的数据
    tag = pd.read_csv('ml-latest/genome-scores.csv').dropna()
movie = pd.read_csv('ml-latest/movies.csv').dropna()
link = pd.read_csv('ml-latest/links.csv').dropna()
tag.movieId = tag.movieId.astype(int)
movie.movieId = movie.movieId.astype(int)
link.movieId = link.movieId.astype(int)
movieIds = set(tag.movieId).intersection(set(movie.movieId)).intersection(set(link.movieId))
omid2nmid={mid:idx for idx,mid in enumerate(movieIds)}
tag.movieId = tag.movieId.apply(lambda x:omid2nmid[x] if x in omid2nmid else np.nan)
tag = tag.dropna().sort_values(by=["movieId","tagId"]).groupby('movieId').apply(lambda df:pd.Series(df['relevance'].tolist()))
np.save('ml-latest/processed_tags.npy',tag.to_numpy())
toptag = np.argsort(-tag.to_numpy())[:,:3]
toptagrelevance = -np.sort(-tag.to_numpy())[:,:3]
  2. userId处理
    先将rating表中的movieId转换为新的movieId，扔掉存在空值的数据，再提取当下rating表userId和user表中userId的交集，并且把rating、user表的userId替换为新的userId，最后扔掉存在空值的数据
    user = pd.read_csv('ml-latest/users.csv',encoding='gbk').dropna()
rating = pd.read_csv('ml-latest/ratings.csv').dropna()
rating.movieId = rating.movieId.apply(lambda x:omid2nmid[x] if x in omid2nmid else np.nan)
rating.userId = rating.userId.apply(lambda x:np.nan if x>user.shape[0] else x)
rating.dropna(inplace=True)
ouid2nuid={oid:idx for idx,oid in enumerate(rating.userId.unique())}
rating.userId = rating.userId.apply(lambda x:ouid2nuid[x])
user.userId = user.userId.apply(lambda x:ouid2nuid[x] if x in ouid2nuid else np.nan)
user.dropna(inplace=True)
np.save('ml-latest/processed_users.npy',user.sort_values(by="userId").reset_index(drop=True).to_numpy())
np.save('ml-latest/processed_ratings.npy',rating.sort_values(by="userId").to_numpy())
  3. movie表处理
    把movie的genre用onehot进行编码，然后把movie,genre,link,tag拼起来
    genres = ["Action","Adventure","Animation","Children's","Comedy","Crime","Documentary","Drama","Fantasy","Film-Noir","Horror","Musical","Mystery","Romance","Sci-Fi","Thriller","War","Western"]
genres2id = {genre:i for i,genre in enumerate(genres)}
np.save('ml-latest/genres2id.npy',genres2id)
movie.movieId = movie.movieId.apply(lambda x:omid2nmid[x] if x in omid2nmid else np.nan)
movie = movie.dropna().sort_values(by="movieId")
link.movieId = link.movieId.apply(lambda x:omid2nmid[x] if x in omid2nmid else np.nan)
link = link.dropna().sort_values(by="movieId")
genre = np.array([''.join(['1' if genre in genre_list else '0' for genre in genres]) for genre_list in movie.genres.str.split('|').tolist()])
np.save('ml-latest/processed_movies.npy',np.concatenate([movie.to_numpy()[:,1:-1],genre.reshape(-1,1),link.to_numpy().astype(np.int64)[:,1:],toptag,toptagrelevance],axis=1))

mycat

  1. mycat2 主要配置文件介绍
    .
├── bin #mycat2 执行文件
├── conf #mycat2 配置文件
│   ├── clusters #集群，用来配置数据库读写分离
│   │   ├── movielens_cluster.cluster.json #movielens结点
│   │   └── prototype.cluster.json #初始结点
│   ├── datasources #数据源，用来配置分布式
│   │   ├── movielens.datasource.json #movielens数据源
│   │   ├── backup.datasource.json #备份数据源
│   │   └── prototypeDs.datasource.json #初始数据源
│   ├── schemas #数据库模式，用来配置数据库分片
│   │   ├── movielens.schema.json #movielens数据库分片配置文件
│   │   ├── mycat.schema.json #mycat数据库
│   │   └── mysql.schema.json #初始数据库
│   ├── server.json #mycat2服务器（虚拟数据库）配置文件
│   ├── sql #一些sql语句便于了解mycat2，替换为自己的sql语句
│   │   ├── create_movie.sql #创建movie分片表
│   │   ├── create_rating.sql #创建rating分片表
│   │   ├── create_user.sql #创建user分片表
│   │   ├── genre.sql #创建genre表并导入数据
│   │   ├── movie.sql #导入movie数据
│   │   ├── rating.sql #导入rating数据
│   │   ├── tag.sql #创建tag表并导入数据
│   │   └── user.sql #导入user数据
│   ├── sqlcaches
│   ├── state.json #mycat2备份配置文件
│   ├── users
│   │   └── root.user.json #mycat2用户配置文件
├── lib #mycat2依赖包
└── logs #日志文件
    ├── mycat.pid
    └── wrapper.log
  2. 以movielens_cluster.cluster.json为例提供读写分离和备份的配置参考
    {
    "clusterType":"MASTER_SLAVE",
    "heartbeat":{
        "heartbeatTimeout":1000,
        "maxRetryCount":3,
        "minSwitchTimeInterval":300,
        "slaveThreshold":0.0
    },
    "masters":[
        "movielens"
    ],
    "maxCon":2000,
    "name":"movielens_cluster",
    "readBalanceType":"BALANCE_ALL",
    "replicas":[
        "backup"
    ],
    "switchType":"SWITCH"
}
  3. 以movielens.datasource.json为例提供（伪）分布式的数据源配置参考
    {
    "dbType":"mysql",
    "idleTimeout":60000,
    "initSqls":[],
    "initSqlsGetConnection":true,
    "instanceType":"READ_WRITE",
    "maxCon":1000,
    "maxConnectTimeout":3000,
    "maxRetryCount":5,
    "minCon":1,
    "name":"movielens",
    "password":"数据库密码",
    "queryTimeout":30,
    "type":"JDBC",
    "url":"jdbc:mysql://127.0.0.1:3306/movielens?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8&autoReconnect=true",
    "user":"root",
    "weight":0
}
  4. 以movielens.schema.json为例提供数据库水平分片的参考配置方法和配置文件
    注：直接修改配置文件会导致在mycat2虚拟数据库上看不到对应的表，因此需要通过mycat2推荐的通过注释构建的方式来实现

    1. create_user.sql

      /*+ mycat:createTable{
	"schemaName":"movielens",
	"shardingTable":{
		"createTableSQL":"CREATE TABLE movielens.user (\n\tuserid INTEGER NOT NULL,\n\tgender VARCHAR(10),\n\tname VARCHAR(255) NOT NULL,\n\tpassword VARCHAR(200) NOT NULL,\n\tcreated_on DATETIME,\n\tlast_login DATETIME,\n\tPRIMARY KEY (userid)\n)",
		"partition":{
				"data":[["movielens_cluster","movielens_1","user_1","0","0","0"],["movielens_cluster","movielens_2","user_2","1","1","1"],["movielens_cluster","movielens_3","user_3","2","2","2"]]
		},
		"function":{
			"clazz":"io.mycat.router.mycat1xfunction.PartitionByMod",
			"properties":{
				"count":"3",
				"columnName":"userid"
			},
            
		}
	},
	"tableName":"user"
} */;

    2. create_movie.sql

      /*+ mycat:createTable{
	"schemaName":"movielens",
	"shardingTable":{
		"createTableSQL":"CREATE TABLE movielens.`movie` (\n\t`movieid` int NOT NULL,\n\t`title` varchar(255) NOT NULL,\n\t`genre` varchar(20) NOT NULL,\n\t`src` varchar(255) DEFAULT NULL,\n\t`imdb` varchar(20) NOT NULL,\n\t`tmdb` varchar(20) NOT NULL,\n\t`tagtop1` int NOT NULL,\n\t`tagtop2` int NOT NULL,\n\t`tagtop3` int NOT NULL,\n\t`relevance1` float NOT NULL,\n\t`relevance2` float NOT NULL,\n\t`relevance3` float NOT NULL,\n\tPRIMARY KEY (`movieid`)\n)",
		"partition":{
				"data":[["movielens_cluster","movielens_1","movie_1","0","0","0"],["movielens_cluster","movielens_2","movie_2","1","1","1"],["movielens_cluster","movielens_3","movie_3","2","2","2"]]
		},
		"function":{
			"clazz":"io.mycat.router.mycat1xfunction.PartitionByMod",
			"properties":{
				"count":"3",
				"columnName":"movieid"
			},
            
		}
	},
	"tableName":"movie"
} */;

    3. create_rating.sql

      /*+ mycat:createTable{
	"schemaName":"movielens",
	"shardingTable":{
		"createTableSQL":"CREATE TABLE movielens.rating (\n\tratingid INTEGER NOT NULL,\n\tuserid INTEGER NOT NULL,\n\tmovieid INTEGER NOT NULL,\n\trating FLOAT NOT NULL,\n\tcreated_on DATETIME,\n\tPRIMARY KEY (ratingid)\n)",
		"partition":{
				"data":[["movielens_cluster","movielens_1","rating_1","0","0","0"],["movielens_cluster","movielens_2","rating_2","1","1","1"],["movielens_cluster","movielens_3","rating_3","2","2","2"]]
		},
		"function":{
			"clazz":"io.mycat.router.mycat1xfunction.PartitionByMod",
			"properties":{
				"count":"3",
				"columnName":"userid"
			},
            
		}
	},
	"tableName":"rating"
} */;

    4. 执行sql

      mysql -uroot -p -Dmovielens -h127.0.0.1 -P8066 
mysql>source create_user.sql;
mysql>source create_movie.sql;
mysql>source create_rating.sql;
mysql>exit;

    5. 最终形成的配置文件

      {
    "customTables":{},
    "globalTables":{},
    "normalTables":{
        "genre":{
            "createTableSQL":"CREATE TABLE movielens.`genre` (\n\t`genreid` int NOT NULL AUTO_INCREMENT,\n\t`genre` varchar(50) NOT NULL,\n\tPRIMARY KEY (`genreid`)\n)",
            "locality":{
                "schemaName":"movielens",
                "tableName":"genre",
                "targetName":"prototype"
            }
        },
        "tag":{
            "createTableSQL":"CREATE TABLE movielens.`tag` (\n\t`tagid` int NOT NULL AUTO_INCREMENT,\n\t`tag` varchar(100) DEFAULT NULL,\n\tPRIMARY KEY (`tagid`)\n)",
            "locality":{
                "schemaName":"movielens",
                "tableName":"tag",
                "targetName":"prototype"
            }
        }
    },
    "schemaName":"movielens",
    "shardingTables":{
        "movie":{
            "createTableSQL":"CREATE TABLE movielens.`movie` (\n\t`movieid` int NOT NULL,\n\t`title` varchar(255) NOT NULL,\n\t`genre` varchar(20) NOT NULL,\n\t`src` varchar(255) DEFAULT NULL,\n\t`imdb` varchar(20) NOT NULL,\n\t`tmdb` varchar(20) NOT NULL,\n\t`tagtop1` int NOT NULL,\n\t`tagtop2` int NOT NULL,\n\t`tagtop3` int NOT NULL,\n\t`relevance1` float NOT NULL,\n\t`relevance2` float NOT NULL,\n\t`relevance3` float NOT NULL,\n\tPRIMARY KEY (`movieid`)\n)",
            "function":{
                "clazz":"io.mycat.router.mycat1xfunction.PartitionByMod",
                "properties":{
                    "count":"3",
                    "columnName":"movieid"
                },
                "ranges":{}
            },
            "partition":{
                "data":[
                    [
                        "movielens_cluster",
                        "movielens_1",
                        "movie_1",
                        "0",
                        "0",
                        "0"
                    ],
                    [
                        "movielens_cluster",
                        "movielens_2",
                        "movie_2",
                        "1",
                        "1",
                        "1"
                    ],
                    [
                        "movielens_cluster",
                        "movielens_3",
                        "movie_3",
                        "2",
                        "2",
                        "2"
                    ]
                ]
            },
            "shardingIndexTables":{}
        },
        "rating":{
            "createTableSQL":"CREATE TABLE movielens.rating (\n\tratingid INTEGER NOT NULL,\n\tuserid INTEGER NOT NULL,\n\tmovieid INTEGER NOT NULL,\n\trating FLOAT NOT NULL,\n\tcreated_on DATETIME,\n\tPRIMARY KEY (ratingid)\n)",
            "function":{
                "clazz":"io.mycat.router.mycat1xfunction.PartitionByMod",
                "properties":{
                    "count":"3",
                    "columnName":"userid"
                },
                "ranges":{}
            },
            "partition":{
                "data":[
                    [
                        "movielens_cluster",
                        "movielens_1",
                        "rating_1",
                        "0",
                        "0",
                        "0"
                    ],
                    [
                        "movielens_cluster",
                        "movielens_2",
                        "rating_2",
                        "1",
                        "1",
                        "1"
                    ],
                    [
                        "movielens_cluster",
                        "movielens_3",
                        "rating_3",
                        "2",
                        "2",
                        "2"
                    ]
                ]
            },
            "shardingIndexTables":{}
        },
        "user":{
            "createTableSQL":"CREATE TABLE movielens.user (\n\tuserid INTEGER NOT NULL,\n\tgender VARCHAR(10),\n\tname VARCHAR(255) NOT NULL,\n\tpassword VARCHAR(200) NOT NULL,\n\tcreated_on DATETIME,\n\tlast_login DATETIME,\n\tPRIMARY KEY (userid)\n)",
            "function":{
                "clazz":"io.mycat.router.mycat1xfunction.PartitionByMod",
                "properties":{
                    "count":"3",
                    "columnName":"userid"
                },
                "ranges":{}
            },
            "partition":{
                "data":[
                    [
                        "movielens_cluster",
                        "movielens_1",
                        "user_1",
                        "0",
                        "0",
                        "0"
                    ],
                    [
                        "movielens_cluster",
                        "movielens_2",
                        "user_2",
                        "1",
                        "1",
                        "1"
                    ],
                    [
                        "movielens_cluster",
                        "movielens_3",
                        "user_3",
                        "2",
                        "2",
                        "2"
                    ]
                ]
            },
            "shardingIndexTables":{}
        }
    },
    "views":{}
}
1746104160
关注
【Mycat 2】详解分库分表设计方案及实操测试（二）
影三人
09-02 420
前一篇的续文。 - 修改了标题编号。
【Mycat 2】详解分库分表设计方案及实操测试（一）
影三人
07-19 542
详解 Mycat 2 分库分表。 - 修正了标题格式错误。
ml-latest.zip
05-06
MovieLens最新数据集-完整版 完整版：280,000名用户将27,000,000个评级和1,100,000个标签应用程序应用于58,000部电影。包括在1,100个标签中具有1400万相关分数的标签基因组数据。上次更新时间9/2018。
mycat2 分库分表
csg103的博客
07-15 1161
mycat2 分库分表
Mycat2分库分表
m0_47944994的博客
11-10 1204
Mycat2分库分表
MyCat2之分库分表
最新发布
Java小菜鸟
05-27 1069
垂直分表: 将⼀个表按照字段分成多表，每个表存储其中⼀部分字段。垂直分库: 根据表的业务不同,分别存放在不同的库中,这些库分别部署在不同的服务器.水平分库: 把⼀张表的数据按照⼀定规则,分配到不同的数据库,每⼀个库只有这张表的部分数据.水平分表: 把⼀张表的数据按照⼀定规则,分配到同⼀个数据库的多张表中,每个表只有这个表的部分数据。
MyCat2数据库分库分表,读写分离中间件(踩坑大实战内附详细图文教程)
暗武逢天的博客
07-28 1879
Mycat 的原理中最重要的一个动词是“拦截”，它拦截了用户发送过来的 SQL 语 句，首先对 SQL 语句做了一些特定的分析：如分片分析、路由分析、读写分离分析、缓存分析等，然后将此 SQL 发往后端的真实数据库，并将返回的结果做适当的处理， 最终再返回给用户
mycat对mysql数据库进行分库分表demo-mycat-demo-parent.zip
11-06
标题"mycat对mysql数据库进行分库分表demo-mycat-demo-parent.zip"揭示了本示例主要围绕MyCat这一中间件，用于MySQL数据库的分布式处理，特别是分库分表功能。MyCat是一个开源的分布式数据库系统，它能够将一个大型...
mycat1.6.5源码，分库分表，分布式
12-22
【标题】"mycat1.6.5源码，分库分表，分布式"涉及到的是一个开源数据库中间件——Mycat，它主要用于解决大数据量下的高性能、高可用性问题，通过分库分表策略来分散数据库负载，实现数据的分布式处理。 【描述】中...
Mycat读写分离、主从切换、分库分表的操作记录- 线上操作手册
01-17
### Mycat读写分离、主从切换、分库分表的操作记录—线上操作手册 #### 一、Mycat简介及关键特性 Mycat是一个开源的分布式数据库系统，能够作为一个中间件帮助开发者管理和优化数据库资源。随着业务增长和技术演进...
mycat2 分库分表配置
weixin_44624815的博客
08-26 1051
mycat2 分库分表
MyCAT2分库分表
qq_52183856的博客
11-21 337
MyCAT2分库分表
JAVA开发（Mycat2分库分表学习）
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
02-07 890
在高性能系统的要求下，复杂的系统当单表数据量增加到几千万甚至上一条记录时，查询延迟无疑是影响高性能系统的瓶颈。业内提供的解决的方案是分库分表，意思是将数据量大的库进行分开，数据量大的表进行分割。通常有横向分割和纵向分割两种模式，其中横向分割较容易。但是当进行数据库分库分表，就产生了另外的问题，就是分布式问题。此时就需要封装一个强大的工具进行屏蔽，使我们在写代码的时候就像只对一个数据库或者一个表进行操作一样。除了使用ShardingShere进行分库分表外，另外的解决方案也可以使用Mycat2中间件
【Mycat2实战】五、Mycat实现分库分表【实践篇】
笑小枫
11-21 1846
本文主要讲如何使用Mycat来实现分库分表。正式配置之前，先声明一下，配置分表这里采用注释配置的方法，配置即可生效并且动态更新Mycat配置并且把配置持久化，具体可参考通过注释配置文档介绍，这个注释配置挺方便的。后面的Mycat分片算法讲解会介绍直接通过建表语句创建分片。这里介绍和上文Mycat已执行的内容均无关联，这里先重置Mycat配置。重置后读写分离文章中相关的配置全部清除。
mycat.zip+分库分表文档
04-15
分库是指将一个大型数据库拆分为多个小型数据库，每个数据库处理一部分数据，以减轻单一数据库的压力；分表则是将一个大表分割为多个小表，通常基于某种规则（如哈希、范围等）分散在不同的数据库中，实现数据的水平...
.NET CORE 分库分表--MyCat
m0_59178355的博客
02-29 3626
当业务表由于数据量大而分片后 ， 业务表与附属的数据字典表之间的关联查询就变成了比较棘手的问题 ， 在MyCat中可以通过数据冗余来解决这类表的关联查询 ， 即所有分片都复制这一份数据（数据字典表），因此可以把这些冗余数据的表定义为全局表。总而言之就是需要进行分片的表。前面讲了数据切分，一个大表被分成若干个分片表，就需要一定的规则，这样按照某种业务规则把数据分到某个分片的规则就是分片规则，数据切分选择合适的分片规则非常重要，将极大的避免后续数据处理的难度。对应用来说，读写数据的表就是逻辑表。
MyCat(二) 分库分表
cjd的博客
12-29 449
1
MyCat2实践（7） - MyCat分库分表
分享Java硬核干货
04-26 1006
因为t_order_detail表是按照order_id取模分表的，所以保证了同一张订单的明细数据都在一张表中。显然是可以的，因为MyCat将order和order_detail作为一个具有关联关系的ER表。接下来，创建一张t_order_detail表，存放订单的明细数据，与t_order表关联。我们打开t_order_detail_0和t_order_detail_1两张表看一下数据。其中的数据并不是按照我们插入的顺序显示的，而是t_ordr_0和t_order_1的拼接。
Mycat2 使用教程（二）分库分表、mysql分库分表
小for学习栏
07-05 811
Mycat2 使用教程（二）分库分表、mysql分库分表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值