首页 > 数据库 >碉堡了!DBMind SQL Rewriter 可以进行SQL自动改写

碉堡了!DBMind SQL Rewriter 可以进行SQL自动改写

时间:2024-04-07 11:59:54浏览次数:14  
标签:test1 name -- DBMind SELECT SQL Rewriter id select

MogDB 3.1版本在AI4DB方面又有很大的增强,其中有一个非常重要的组件DBmind,引入了一个SQL改写工具即 SQL Rewriter。根据预先设定的规则,将查询语句转换为更为高效或更为规范的形式,使得查询效率得以提升。这里我们就为大家简单演示一下其具体的用法。

首先准备一下环境

MogDB 3.1环境缺少constant 文件,因此需要先安装一堆Python依赖包。

cat >> $GAUSSHOME/bin/constant <<EOF
 MIN_PYTHON_VERSION="(3,6)"
MAX_PYTHON_VERSION="(3,9)"
EOF

可以通过查看$GAUSSHOME/bin/dbmind/requirements-aarch64.txt 来确认具体的环境要求。

我们先配置好PIP环境.

mkdir -p ~/.pip
cat > ~/.pip/pip.conf <<EOF
[global]

index-url = https://repo.huaweicloud.com/repository/pypi/simple

[install]

trusted-host = https://repo.huaweicloud.com

准备就绪之后,就可以开始安装python依赖包了。

python3 -m pip  install --upgrade pip --user

python3 -m pip install -r $GAUSSHOME/bin/dbmind/requirements-aarch64.txt  --trusted-host repo.huaweicloud.com -i http://repo.huaweicloud.com/repository/pypi/simple --user

 python3 -m pip  install psycopg2 --user
如果报错,换成
 python3 -m pip  install psycopg2-binary --user

万事俱备,只欠东风!接下来我们就来测一测DBmind的能力,这里我就为大家揭开神秘面纱。

先来了解一下这个强大的AI工具的基本用法:

gs_dbmind component sql_rewriter [PORT] [DBNAME] [SQLFILE] --db-host [default socketfile] --db-user [default init user] --schema [default public]

当然对于其支持的自动改写规则,也并非是所有的都支持,目前暂时支持如下的一些rule。

class Delete2Truncate(Rule):
class Star2Columns(Rule):
class Having2Where(Rule):
class AlwaysTrue(Rule):
class DistinctStar(Rule):
class UnionAll(Rule):
class OrderbyConst(Rule):
class Or2In(Rule):
class OrderbyConstColumns(Rule):
class ImplicitConversion(Rule):
class SelfJoin(Rule):
  

这里我们事先准备好一些相对简单的测试用例,内容如下:

cat > rewrite_example.sql <<EOF
delete /* 无条件的delete转换成truncate */ 
from test1;
select /* 星号替换成具体列名 */ * 
from test1;
select /*Union替换成 Union All*/id,name 
from test1
union 
select id,name 
from test2;
select /*order by 列号替换成具体列名 */id,name 
from test1 order by 1;
select /*返回单行的去掉order by */ id 
from test1 where id=1 order by id;
select /*Or 改为 in */id,name 
from test1 where id = 0 or id = 1;
select /* Having 列不属于聚合函数的改成Where */ id,count(*) 
from test1 group by id having id > 0 ;
select /*去掉恒为True的表达式*/id,name 
from test1 where 1=1;
select  /*预计算转换*/ id,name 
from test1 where id + 1 < 2 ;
select /*自连接非等式连接改为等式连接*/ a.id,b.name 
from test1 a , test1 b
 where a.id - b.id <= 20 and a.id > b.id;
select /*distinct 带主键去掉distinct */  distinct * 
from test1;
EOF
  

测试脚本准备完毕之后,我们就可以使用DBmind来验证一下其改写能力了。具体的执行命令如下:

gs_dbmind component sql_rewriter $PGPORT postgres rewrite_example.sql --db-user tpcc  --db-host 127.0.0.1

最后我们来看看dbmind执行的结果如想象的那般神奇。

+-------------------------------------------------------+----------------------------------------------------+
| Raw SQL                                               | Rewritten SQL                                      |
+-------------------------------------------------------+----------------------------------------------------+
| delete                                                | TRUNCATE TABLE test1;                              |
| /* 无条件的delete转换成truncate */                    |                                                    |
| from test1;                                           |                                                    |
| select                                                | SELECT id,                                         |
| /* 星号替换成具体列名 */ *                            |        name                                        |
| from test1;                                           | FROM test1;                                        |
| select                                                | SELECT id,                                         |
| /*Union替换成 Union All*/id,name                      |        name                                        |
| from test1                                            | FROM test1                                         |
| union                                                 | UNION ALL                                          |
| select id,name                                        | SELECT id,                                         |
| from test2;                                           |        name                                        |
|                                                       | FROM test2;                                        |
| select                                                | SELECT id,                                         |
|  /*order by 列号替换成具体列名 */id,name              |        name                                        |
| from test1 order by 1;                                | FROM test1                                         |
|                                                       | ORDER BY id;                                       |
| select                                                | SELECT id                                          |
|  /*返回单行的去掉order by */ id                       | FROM test1                                         |
| from test1 where id=1 order by id;                    | WHERE id = 1;                                      |
| select                                                | SELECT id,                                         |
|  /*Or 改为 in */id,name                               |        name                                        |
| from test1 where id = 0 or id = 1;                    | FROM test1                                         |
|                                                       | WHERE id IN (0,                                    |
|                                                       |              1);                                   |
| select                                                | SELECT id,                                         |
| /* Having 列不属于聚合函数的改成Where */ id,count(*)  |        COUNT(*)                                    |
| from test1 group by id having id > 0 ;                | FROM test1                                         |
|                                                       | WHERE id > 0                                       |
|                                                       | GROUP BY id;                                       |
| select                                                | SELECT id,                                         |
| /*去掉恒为True的表达式*/id,name                       |        name                                        |
| from test1 where 1=1;                                 | FROM test1;                                        |
| select                                                | SELECT id,                                         |
| /*预计算转换*/ id,name                                |        name                                        |
| from test1 where id + 1 < 2 ;                         | FROM test1                                         |
|                                                       | WHERE id < 1;                                      |
| select                                                | SELECT *                                           |
| /*自连接非等式连接改为等式连接*/ a.id,b.name          | FROM                                               |
| from test1 a , test1 b                                |   (SELECT a.id,                                    |
|  where a.id - b.id <= 20 and a.id > b.id;             |           b.name                                   |
|                                                       |    FROM test1 AS a,                                |
|                                                       |         test1 AS b                                 |
|                                                       |    WHERE TRUNC((a.id) / 20) = TRUNC(b.id / 20)     |
|                                                       |      AND a.id > b.id                               |
|                                                       |    UNION ALL SELECT a.id,                          |
|                                                       |                     b.name                         |
|                                                       |    FROM test1 AS a,                                |
|                                                       |         test1 AS b                                 |
|                                                       |    WHERE TRUNC((a.id) / 20) = TRUNC(b.id / 20 + 1) |
|                                                       |      AND a.id - b.id <= 20);                       |
| select                                                | SELECT id,                                         |
| /*distinct * 带主键去掉distinct */  distinct *        |        name                                        |
| from test1;                                           | FROM test1;                                        |
+-------------------------------------------------------+----------------------------------------------------+

我们可以看到DBmind完美的改写了11个SQL。 怎么样,是不是很Cool~~~~

本文由 mdnice 多平台发布

标签:test1,name,--,DBMind,SELECT,SQL,Rewriter,id,select
From: https://blog.csdn.net/lovewifelovelife/article/details/137437451

相关文章

  • MySQL中COUNT(1)、COUNT(*)、COUNT(字段)
    COUNT1):COUNT(1)会统计符合条件的结果集的行数,表示统计结果集中的行数,而括号内的值不影响结果。使用COUNT(1)可以更快地执行统计,因为不需要实际检查行的数据内容。COUNT(*):COUNT(*)会统计符合条件的结果集的行数,与COUNT(1)类似,但不同的是COUNT(*)会检查行中具体的数据......
  • 【阅读笔记】MySQL的多版本并发控制(MVCC-Multiversion Concurrency Control)
    摘自:高性能MySQL(第四版)MVCC的作用InnoDB和XtraDB存储引擎通过多版本并发控制(MVCC,MultiversionConcurrencyControl)解决了幻读的问题MVCC的应用MySQL的大多数事务型存储引擎使用的都不是简单的行级锁机制。它们会将行级锁和可以提高并发性能的多版本并发控制(MVCC)技术结合使用......
  • Mac安装压缩版MySQL Server
    本文详细记录一次在Mac中安装MySQLServer的过程,安装环境如下:MacOS14.4x86,corei7在MySQL数据库实验环境下通常都要安装其MySQLServer,安装方式五花八门,最简单的有通过系统包管理工具一键安装,例如apt和yum等,这种安装方法会使得MySQL按照标准设计将文件分散在多个文件路径......
  • MySQL 主从 AUTO_INCREMENT 不一致问题分析
    作者:vivo互联网数据库团队-WeiHaodong本文介绍了MySQL5.7中常见的replaceinto操作造成的主从auto_increment不一致现象,一旦触发了主从切换,业务的正常插入操作会触发主键冲突的报错提示。一、问题描述1.1问题现象在MySQL5.7版本中,REPLACEINTO操作在表存在自增......
  • 深入探索MySQL:成本模型解析与查询性能优化,及未来深度学习与AI模型的应用展望
    码到三十五:个人主页在数据库管理系统中,查询优化器是一个至关重要的组件,它负责将用户提交的SQL查询转换为高效的执行计划。在MySQL中,查询优化器使用了一个称为“成本模型”的机制来评估不同执行计划的优劣,并选择其中成本最低的那个。本文将深入探讨MySQL的成本模......
  • MySQL分组查询以及内连接查询
    DDLCREATETABLE`student`(`id`int(11)NOTNULLAUTO_INCREMENTCOMMENT'学号',`createDate`datetimeDEFAULTNULL,`userName`varchar(20)DEFAULTNULL,`pwd`varchar(36)DEFAULTNULL,`phone`varchar(11)DEFAULTNULL,`age`tinyint(......
  • 一条SQL查询语句是如何执行的
    这是专栏的第一篇文章,我想来跟你聊聊 MySQL 的基础架构。我们经常说,看一个事儿千万不要直接陷入细节里,你应该先鸟瞰其全貌,这样能够帮助你从高维度理解问题。同样,对于 MySQL 的学习也是这样。平时我们使用数据库,看到的通常都是一个整体。比如,你有个最简单的表,表里只有一个 ID......
  • MySQL左右连接查询
    DDLCREATETABLE`student`(`id`int(11)NOTNULLAUTO_INCREMENTCOMMENT'学号',`createDate`datetimeDEFAULTNULL,`userName`varchar(20)DEFAULTNULL,`pwd`varchar(36)DEFAULTNULL,`phone`varchar(11)DEFAULTNULL,`age`tinyint(......
  • MySQL左右表联合查询
    DDLCREATETABLE`student`(`id`int(11)NOTNULLAUTO_INCREMENTCOMMENT'学号',`createDate`datetimeDEFAULTNULL,`userName`varchar(20)DEFAULTNULL,`pwd`varchar(36)DEFAULTNULL,`phone`varchar(11)DEFAULTNULL,`age`tinyint(......
  • MySQL多表联合查询+分组+排序
    DDLCREATETABLE`student`(`id`int(11)NOTNULLAUTO_INCREMENTCOMMENT'学号',`createDate`datetimeDEFAULTNULL,`userName`varchar(20)DEFAULTNULL,`pwd`varchar(36)DEFAULTNULL,`phone`varchar(11)DEFAULTNULL,`age`tinyint(......