Db on IT 运维小秋

mysql常用命令

chenwx716@139.com — Sat, 03 May 2025 22:12:48 +0800

常用工具命令集合


-- 查看长时间运行的查询
SELECT id, user, host, db, command, time, state, LEFT(info, 100) as query
FROM information_schema.processlist
WHERE time > 30
  AND command != 'Sleep'
ORDER BY time DESC;

-- 杀死长时间运行的查询
KILL QUERY <process_id>;

定位cpu占用过高的sql

定位线程

# 找出mysql 的进程号
ps -ef | grep mysql

# 根据进程号，找出占用CPU靠前的线程号
top -H -p <mysqld进程id>

数据库定位sql

SELECT
    a.USER,
    a.HOST,
    a.db,
    b.thread_os_id,
    b.thread_id,
    a.id processlist_id,
    a.command,
    a.time,
    a.state,
    a.info
FROM
    information_schema.PROCESSLIST a,
    performance_schema.threads b
WHERE
    a.id = b.processlist_id
AND b.thread_os_id = <具体线程id>;

mysql备份恢复常用

chenwx716@139.com — Fri, 03 May 2024 22:12:48 +0800

备份注意事项

基本原则

备份文件不要放在同一个主机上, 异地备份
备份文件需要校验hash并记录
需要偶尔去验证一下备份恢复流程是否可行
性能敏感性，避免在主库上备份, 去二级数据库上进行备份
注意binlog文件的连续性
对重点表进行单独表级别的备份
lvm或存储层的快照备份不可靠
重要业务可以考虑一个延迟同步实例

恢复场景

全量恢复
单库恢复
单表或多表
单表内的部分行
某1条数据

恢复方式

使用物理备份文件全覆盖
从逻辑备份文件恢复到指定库
从备份文件 -> 新的恢复专用空库 -> 提取数据 -> 恢复到生产库
从 binlog 中提取 sql –> 编辑sql –> 恢复(insert/update)

恢复校验: 基础校验(大小, 行数) + 业务校验(金额, 时间, 状态等业务指标)

其它

备份时附加记录的元数据:
备份时间, 文件大小, 文件hash, 行数, 表数量, 备份使用的完整命令等

热备份: 读写不受影响
温备份: 类似于只读从库, 实时同步但仅可以执行读操作
冷备份: 离线备份

备份组合: 每周全量 + 每日增量 + 实时备份(同步binlog)

常用工具简介

mysqldump
优点: 自带工具, 一般够用
缺点: 因为是逻辑备份, 所以备份和恢复耗时都比较长

xtrabackup
物理备份, 备份和恢复速度快, 可以不影响数据库服务情况下进行热拷贝

mysqlpump
5.7+ 新增的官方备份工具，是 mysqldump 的一个衍生；
支持基于库和表的并行导出

mydumper
早期的并行dump工具

逻辑备份和物理备份

逻辑备份的特点是: 恢复时内容是需要被执行的, 本质是插入sql

优点: 跨版本迁移方便, 适合升级前备份, 支持编辑后恢复

物理备份的特点是: 拷贝的底层数据文件, 恢复时可以直接启动, 不需要再执行一遍sql;(增量的部分是重放redo)

优点: 速度快，缺点: 空间占用大, 不能跨版本和平台进行迁移。

增量备份的方式

非侵入型

刷新binlog后，备份增量的binlog文件
xtrabackup 的增量备份

侵入型

纯插入场景, 记录下每次的 id 偏移量, 然后备份新增部分
表内如果有 update_time 字段, 备份时按时间筛选
准备一个备份状态表, 管理备份的阶段信息
触发器模式
etl 模式

恢复

# 直接加载文件
mysql>source url\file.sql

# 非交互式恢复
mysql -uroot -p123 -h 192.x.x.x < /backup/alldb.sql

在线恢复

禁止普通用户写, 只允许超级用户写(便于导入数据)

1
2

set read_only=on;
set super_read_only=off;

加速恢复速度；

可以先关闭普通索引

1
2
3

alter table t_name disable keys     -- 关闭普通索引
load data infile file.txt
alter table t_name enable keys      -- 开启普通索引

如果确定导入值不会冲突, 可以先关闭唯一索引检查; 仅适用于InnoDB, 必须在事务外使用;

1
2

set unique_checks=0     -- 关闭
set unique_checks=1     -- 开启

针对 innodb 表, 如果导入数据是按主键顺序排列，可以提高导入效率
关闭自动提交，在导入完成后，再开启也会加快导入速度
关闭 binlog
innodb_flush_log_at_trx_commit=0

基于 binlog 的恢复

导出mysql-bin.00000012二进制文件进行还原及时点

1
2
3

# 一般不这样搞, 除非场景特别简单
mysqlbinlog mysql-bin.00000012 > tmp.sql
mysql -uroot -p < tmp.sql

mysqldump

主要参数


-A --all-databases      # 导出所有数据库
-B --databases          # 指定数据库, 支持多库; 单库时可以省略

--tables                # 指定表, 会覆盖 --databases or -B 选项
--ignore-table=db1.t1   # 忽略表, 指定多个

-F, --flush-logs
    # 开始导出前刷新 binlog 日志, 方便后续的增量备份或添加从库
    注意: 假如一次导出多个数据库(使用选项 --databases 或者 --all-databases),
    将会逐个数据库刷新日志;
    除使用 --lock-all-tables 或者 --master-data 外;
    在这种情况下, 日志将会被刷新一次, 相应的所以表同时被锁定;
    因此, 如果打算同时导出和刷新日志应该使用 --lock-all-tables 或者 --master-data 和 --flush-logs;
    会执行 FLUSH TABLES, 等待关闭全部表

--extended-insert       # 将多行数据合并成一个 insert 语句, 默认有开启
--skip-extended-insert  # 关闭 sql 合并, 导出 sql 时, 将每行数据生成一个 insert 语句

-t, --no-create-info    # 只有数据, 不包含创建表等创建动作, 即只有 insert

--master-data=[1,2]
--source-data[=#]
    # 5.8+ 改名为 source-data
    # 将 binlog 的位置和偏移量 追加到输出文件中;
    # 1 输出 CHANGE MASTER 命令;
    # 2 输出的 CHANGE MASTER 命令前有添加注释信息;

    # 该选项将打开 --lock-all-tables 选项,
    # 除非 --single-transaction 也被指定, 该选项自动关闭 --lock-tables 选项;

    # 添加该选项时, 为了获取 show master status 信息, 会获取一次全局锁,
    # 不应该高频率地使用此选项, 单库备份这种频率较低的可以使用

--dump-slave[=#]
--dump-replica[=#]
    # 和 source-data 效果一样, 只是方便从库添加

--include-master-host-port
    # 配合 --dump-slave 使用, 在文件内添加主节点的ip和端口, 方便直接添加从库


-w, --where=name        # 只备份符合条件的, 一般用于增量备份

-d --no-data            # 只导出表结构

-q --quick
    # 强制 mysqldump 从服务器每次查询一行数据而不是查询整个表;
    # 避免大表导出时查询刷爆内存且热点数据被刷出缓冲池, 通常建议总是启用该选项;

--single-transaction
    # 在单个事务中执行动作; 保证一致性和解决 锁表的问题
    # 当只使用此选项进行备份时, 不会产生表锁
    # 适用于 InnoDB 存储引擎, 需要确保导出时无 DDL 操作
    # 此选项会自动关闭 --lock-tables

-l, --lock-tables
    # 写锁, 导出过程中依次锁住每个 schema 下所有表(只能保证各 schema 下表导出的一致性),
    # 被锁的表只能读, MyISAM 存储引擎常用

--skip-lock-tables

-x, --lock-all-tables
    # 提交请求锁定所有数据库中的所有表, 以保证数据的一致性;
    # 这是一个全局读锁, 并且自动关闭 --single-transaction 和 --lock-tables 选项;
    # 适合 MyISAM 存储引擎

--flush-privileges
    # 有与 mysql 这个库相关的数据导出时, 最好是添加这个
    # 在转储 mysql 数据库后, 发出一个 FLUSH PRIVILEGES 语句

--triggers          # 转储触发器, 默认关闭

--skip-triggers
    默认导出表中是带着触发器的, 不要触发器可以用 --skip-triggers

-n, --no-create-db

-Y, --all-tablespaces   导出全部表空间
-y, --no-tablespaces    # Do not dump any tablespace information 不导出任何表空间信息

--add-drop-database
--add-drop-database     Add a DROP DATABASE before each create.
--add-drop-table        # 在每个 create 语句之前增加一个 drop table; 默认为 if drop
--skip-add-drop-table   # 不添加 if drop; 直接就是 create


# data
--add-locks         # 在 INSERT 语句前添加 lock
--allow-keywords    # 允许使用关键字 做为列名
--ignore-error=name
--ignore-table=name

-E, --events        # Dump events 事务; mysqldump 默认没有导出事务和存储过程
-R --routines       # 转储存储过程(函数和过程)

--hex-blob
    # 以十六进制格式转储二进制字符串(BINARY, VARBINARY, BLOB);
    # 避免导出的二进制字符串乱码

--set-gtid-purged=OFF   # 关闭 gtid 相关的事件转储

--net-buffer-length=
    # TCP/IP和套接字通信的缓冲区大小
    # 导出值不能比目标数据库的值大

--max-allowed-packet=
    # 发送到服务器或从服务器接收的最大数据包长度

--tz-utc                # 需要跨时区导入导出时, 需要添加
                        # 会自动转换 TIMESTAMP 字段内容为 utc0 时区的时间,
                        # 并设置在导出文件顶部设置时区 TIME_ZONE='+00:00'
                        # 只影响 TIMESTAMP 类型, DATETIME 等不受影响

实例

单表

# 普通备份
# DROP TABLE IF EXISTS; CREATE TABLE; LOCK TABLES; INSERT INTO; UNLOCK TABLES;
mysqldump db t1 > t1.sql

# 备份表数据 - 只有数据不含创建表
# LOCK TABLES; INSERT INTO; UNLOCK TABLES;
mysqldump -t db t1 > t1.sql

# 备份表结构
# DROP TABLE IF EXISTS; CREATE TABLE;
mysqldump -d db1 t_1 > t_1.sql

# 多表
mysqldump db t1 t2 t3 > t_all.sql

# 排除部分表
mysqldump db1 --ignore-table=db1.test1 --ignore-table=db1.test2 > /data/bak/db1.sql

# 指定 where 条件导出表的部分数据
mysqldump -w "id=6032" t_1 > /tmp/where.sql

单库

# 普通备份; 即多个 普通表 备份的组合
mysqldump db1 > db1-db.sql

# 仅导出单个 db 数据
mysqldump -u root -p db1 -t > /data/bak/db1.sql

# 单库备份 - 只备份表结构
mysqldump -d -B db1  > db1-db.sql

多库

# 全量备份所有内容 - 常用
mysqldump -u root -p \
    --all-databases --add-drop-table --routines --triggers --events \
    > /path/to/full_backup_$(date +%Y%m%d).sql

# 导出所有 db 结构和数据
mysqldump -uroot -p -A > /data/bak/all.sql

# 导出所有 db 结构
mysqldump -uroot -p -A -d > /data/bak/all_struct.sql

# 仅导出所有 db 数据不导表结构
mysqldump -uroot -p -A -t > /data/bak/all_data.sql

# 导出多个指定 db
mysqldump --databases db1 db2 > /data/bak/muldbs.sql

特殊场景


# 单库备份命令(推荐); 在单个事务中执行备份, 并且刷新 binlog
mysqldump -h 10.2.1.5 -u root -p -A \
--source-data=2 --single-transaction --flush-logs > back-2023-03-21.sql

mysqldump --master-data=2 --lock-all-tables --flush-logs  --all-databases > /root/alldb.sql

# 普通备份, 不记录 gtid
mysqldump -u root -p -B doc \
    --set-gtid-purged=OFF \
    --single-transaction > db_doc-2023-02-09.sql


# 备份 -> 恢复 | 异机恢复
mysqldump -h host1 -u root -p -B db1 --tables t1 | mysql -h host2 -u user1 -p db2


# 备份-压缩-恢复 适合小数据量场景
mysqldump -h host1 -u user1 -p'pw' mydb | gzip > mydb.sql.gz
gunzip < mydb.sql.gz | mysql -h host2 -u user1 -p'pw' mydb


# 条件备份+过滤恢复+严格确认数据
mysqldump -u root -p -S /data/mysql_3306/mysql.sock \
--databases cmcc --tables t_name \
--where='VERIFY_TIME BETWEEN "2018-03-29 03:00:00" and "2018-03-29 03:59:59"' >> c1.sql

grep --ignore-case 'insert into `t_name`' c1.sql >> xxx.sql
sed -i '/t_name/s/t_name/t_name_0711/g' xxx.sql

/opt/app/mysql/bin/mysql -u root -p cmcc < xxx.sql
INSERT INTO t_name SELECT * FROM t_name_0711;

脚本实例

脚本1

#!/bin/bash
# mysql_backup
# 0 3 * * * sh /bigdata/mysql_backup.sh >> /bigdata/mysql_backup.log 2>&1 &

# 完善的备份机制
# 1. 启动前检查实例是否具备可备份状态;
# 包括是否在线, 当前负载，磁盘空间是否足够，远程服务器是否能连接
# 2. 备份 -> 压缩 -> 异地同步
# 3. md5 检验, 避免以后文件传输过程中损坏


DB_USER="root"
DB_PASS="password"
DB_HOST="192.168.1.100"
BACK_BASE_DIR="/bigdata/mysql"
LOG_FILE=${BACK_BASE_DIR}/backup.log
DUMP="/usr/local/mysql/bin/mysqldump"

REMOTE_SERVER="10.2.1.5"
REMOTE_USER="user1"
REMOTE_DIR="/data/mysql_backup"


function log() {
    echo "$(date "+%F %H:%M:%S") $@" >> $LOG_FILE
}
#===================================================================
# pre
# 获取当前日期 2024-02-03
DATE=`date +%F`

BACK_DIR=${BACK_BASE_DIR}/${DATE}
BACK_FILE=${BACK_DIR}/mysql_backup_${DATE}.sql

log "start backup"
mkdir -p $BCK_DIR/$DATE
#===================================================================

$DUMP -u$DB_USER -p$DB_PASS -h$DB_HOST --all-databases > ${BACK_FILE}

log "backup end, start compress"
#===================================================================

gzip ${BACK_FILE}

# 可选并行压缩
# pigz -9 -p 24 ${BACK_FILE}

log "backup task compress end"

#==========================================================
# CHECK FILE MD5SUM

log "pre check file md5sum"

md5sum ${BACK_FILE}.gz >> $LOG_FILE

log "check file md5sum end"
#==========================================================
# old file clear

yestoday=$(date -d '-7 day' +%Y-%m-%d)  # 取 7 天前的时间

log "delete old backup file"
log "del ${BACK_BASE_DIR}/${yestoday}"

rm -rf ${BACK_BASE_DIR}/${yestoday}

log "del old backup file end"

# 只保留最近一周的备份
# find ${BACK_BASE_DIR} -mtime +2 -exec rm -rf {} \;

#==========================================================
log "start sync backup file to remote server"

scp -r ${BACK_DIR} ${REMOTE_USER}@${REMOTE_SERVER}:${REMOTE_DIR}

log "all task end"
#==========================================================

脚本2

#!/bin/sh
# 1. 先停止复制 - 保障一致性
# 2. 备份完成后再开启同步

mkdir -p /server/backup/
mysql -u$USER -p$PASS -S $SOCK -e "stop slave SQL_THREAD;"

# 实际上还需要排除系统库 mysql|information_schema|performance_schema
DB_LIST=$(mysql -u$USER -p$PASS -S $SOCK  -e "show databases"|sed '1,2d'|/bin/egrep -v "${EXCLUDE[*]}")

for dbname in ${DB_LIST}
do
   TABLE_LIST=$(mysql -u$USER -p$PASS -S $SOCK  -e "show tables from $dbname;"|sed '1d')
   for tablename in ${TABLE_LIST}
   do
      mkdir -p /server/backup/$DATE/$dbname
      mysqldump --lock-tables=0 -u$USER -p$PASS -S $SOCK  ${dbname}  $tablename |gzip >/server/backup/$DATE/${dbname}/${dbname}_${tablename}_$DATE.sql.gz
   done
done
mysql -u$USER -p$PASS -S $SOCK  -e "start slave SQL_THREAD;"

关于备份时的锁

避免只使用 --master-data=2 选项, 此选项会获取全局锁, 大量表频繁获取时, 容易阻塞业务。

最好是始终使用 --single-transaction 参数, 避免一直锁定。

--lock-all-tables 或 --lock-tables 参数, 会加锁；

加 --master-data=2 或 --flush-logs 参数时, 会执行:
FLUSH TABLES;
FLUSH TABLES WITH READ LOCK;
不加锁, 但是会导致备份时间延长, 或无法备份完成

FLUSH TABLES

FLUSH TABLES 关闭所有打开的表, 强制关闭所有正在使用的表, 并刷新查询缓存和预准备语句缓存, 不会刷新脏块,
会被锁阻塞, 会等待所有正在运行的 SQL 执行结束

如果当前有正在运行的慢 SQL, 执行 FLUSH TABLES; 就会被阻塞, 需要等待 SQL 执行结束

FLUSH TABLES WITH READ LOCK
关闭所有打开的表并使用全局读锁锁定所有数据库的所有表, 不会刷新脏块,会被锁阻塞
如果存在锁, FLUSH 会直接返回错误

OUTFILE

OUTFILE 文本备份

理解为导出 csv

SELECT ... INTO OUTFILE

--- 查询输出到一个文件
select * from my_t1 into outfile "d:/my_t1.txt";

--- 指定分隔符
select id from test where id > 0
 into outfile 'c:\\test'
 FIELDS TERMINATED by ',' ENCLOSED by "" LINES TERMINATED by '\n';

OUTFILE控制格式

-- 控制格式
-- TERMINATED 生成的数据分隔符, 默认是制表符
-- ENCLOSED 包裹
-- ESCAPED 转义字符

-- FIELDS 子句的缺省值是,
FIELDS TERMINATED BY '\t' ENCLOSED BY '' ESCAPED BY '\\'

-- LINES 控制行格式, 子句的缺省值是
LINES TERMINATED BY '\n'

load data 文本导入

load data  [low_priority] [local] infile 'file_name.txt' [replace | ignore] into table t_name [控制格式]

-- local 在客户端查找文件, 未添加时在服务器查找文件
-- replace 和 ignore 关键词控制对现有的唯一键记录的重复的处理

load data infile "d:/home_my_email" into table wait.my_email;
load data infile "d:/home_my_email" into table wait.my_email(name);    -- 指定字段
load data local infile "F:/account_data/971.txt" into table t_name;

-- 指定使用,号 和 换行做分隔符；
load data infile '/home/data.txt' into table t_name fields terminated by ',' lines terminated by '\n';

-- 实例
mysql -uroot -p$pw -Dcmcc \
-e "load data local infile '/home/mysql/data/t1.txt' into table t_name fields terminated by ','";

恢复错误处理

1
2

ERROR at line 3130: Unknown command '\''.
# 字符集问题，使用  --default-character-set=utf8mb4 参数指定字符集

mysql-xtrabackup

chenwx716@139.com — Wed, 03 May 2023 22:12:48 +0800

简要说明

物理备份

流程: 备份 -> 恢复准备 -> 恢复

innobackupex 原本只是一个 perl 脚本，实际还是调用 xtrabackup 命令

备份过程
连接数据库, 开始拷贝 redo log, 拷贝 innodb 表文件,
锁表, 拷贝非 innodb 表文件, 停止拷贝 redo log, 解锁

全量备份

说明: 如果备份时主库不进行数据写入，
则备份文件直接 mv 到datadir 即可跳过准备和 copy-back 两阶段进行恢复；
如果在备份时主库有数据写入，则恢复时一定要进行准备步骤

# 完全备份
innobackupex --defaults-file=/opt/app/mysql/my.cnf \
--user=root --password=xxxxx1 /new_data/mysql_backup \
-S /data/mysql_data/mysql.sock --parallel=10

# 全量备份-加多线程执行
innobackupex --user=root --password=passw0rd /home/user1/mysql_back1 \
-S /home/user1/data/mysql_data/mysqld.sock \
    # 并行 10 线程，限制 IO为每秒 400次
    --parallel=10 --throttle=400

记录偏移量输出，方便后续添加从库

180302 14:09:11 innobackupex: Starting the backup operation

180302 14:12:44 Backup created in directory '/home/user1/backup/2018-03-02_14-09-11/'
MySQL binlog position: filename 'mysql-binlog.000058', position '158473483', GTID of the last change '9d1b2f2d-e3d7-11e7-a416-0025b511001f:1-38583130'
    # 服务器最新的 binlog 文件和 post 号
    # 用于从库新增主库时使用
xtrabackup: Transaction log of lsn (121009498133) to (121014178723) was copied.
180302 14:12:44 completed OK!

# 后续的命令
CHANGE MASTER TO
    MASTER_HOST='10.1.1.78',
    MASTER_PORT=3306,
    MASTER_USER='sync',
    MASTER_PASSWORD='xxxxx',
    MASTER_LOG_FILE='mysql-binlog.000058',
    MASTER_LOG_POS=158473483;

全量备份的恢复

恢复准备-prepare

innobackupex --defaults-file=/opt/app/mysql/my.cnf \
--use-memory=64G --apply-log /data/mysql_backup/2018-04-10_01-56-48


# --use-memory=64G 这个参数只在准备阶段可用

恢复-拷贝数据

# 注意删除原数据目录
innobackupex --defaults-file=/opt/app/mysql/my.cnf \
--copy-back /data/mysql_backup/2018-04-10_01-56-48

--rsync

增量备份

原理：
每个 InnoDB 的页面都会包含一个 LSN 信息, 每当相关的数据发生改变, 相关的页面的 LSN 就会自动增长;
这正是 InnoDB 表可以进行增量备份的基础,
即 innobackupex 通过备份"上次完全备份之后发生改变的页"来实现;

实例

--incremental           # 本次增量备份的路径, 会自动按日期创建子目录
--incremental-basedi    # 指向上次增量备份的路径, 首次增量备份则是指向第一次的全量备份的路径

# 首次增量备份
innobackupex --defaults-file=/etc/my.cnf \
    --user=user1 --password=123456 --socket=/tmp/mysql.sock \
    --incremental /data/user1/inc \
    --incremental-basedir=/data/user1/2017-04-24_02-46-11/ \
    --parallel=2        # 并行 2 线程

# 后续增量备份
innobackupex --defaults-file=/etc/my.cnf \
    --user=user1 --password=123456 --socket=/tmp/mysql.sock \
    --incremental /data/user1/inc \
    --incremental-basedir=/data/user1/inc/2017-04-28_01-09-40/ \
    --parallel=2

恢复

准备数据(预处理)
拷贝数据

prepare-准备

需要在每个备份(包括完全和各个增量备份)上, 将已经提交的事务进行"重放";
“重放"之后, 所有的备份数据将合并到完全备份上;
基于所有的备份将未提交的事务进行"回滚”;

注意: 合并的增量备份要去掉

# 准备开始的全量备份
innobackupex --apply-log --redo-only full_bk_dir

# 合并第一个增量备份
innobackupex --apply-log --redo-only full_bk_dir --incremental-dir=INCREMENTAL-DIR-1

# 合并第二个增量备份
innobackupex --apply-log --redo-only full_bk_dir --incremental-dir=INCREMENTAL-DIR-2

# 合并最后一份增量备份 - 最后一次不加 --redo-only
innobackupex --apply-log full_bk_dir --incremental-dir=INCREMENTAL-DIR-3

# 合并最终备份
innobackupex --apply-log full_bk_dir

prepare-恢复
与全量恢复时无差异

# 恢复完整备份
innobackupex --defaults-file=/etc/mysql/my.cnf \
    --copy-back /mysql_backup/2015-02-08_11-56-48/

# 修改恢复数据文件权限
chown -R mysql.mysql /var/lib/mysql

/etc/init.d/mysqld start

最小备份权限的用户


-- 备份数据需要的最小权限
CREATE USER 'bkuser1'@'localhost' IDENTIFIED BY 's3cret';
REVOKE ALL PRIVILEGES, GRANT OPTION FROM 'bkuser1';
GRANT RELOAD, LOCK TABLES, REPLICATION CLIENT ON *.* TO 'bkuser1'@'localhost';
FLUSH PRIVILEGES;

-- 备份用户所需要的权限
CREATE USER 'bkuser1'@'localhost' IDENTIFIED BY 'bkppass';
GRANT RELOAD, LOCK TABLES, REPLICATION CLIENT,PROCESS,SUPER ON *.* TO 'bkuser1'@'localhost';
FLUSH PRIVILEGES;

mysqlpump工具介绍

chenwx716@139.com — Wed, 03 May 2023 22:12:48 +0800

简介

并行导出的架构为: 队列(库) + 线程(表)

并行度最细细为表级别

特性:

属于逻辑备份
并行备份数据库和数据库中的对象的, 加快备份过程
更好的控制数据库和数据库对象(表, 存储过程, 用户帐户)的备份
备份用户账号作为帐户管理语句(CREATE USER, GRANT), 而不是直接插入到 MySQL 的系统数据库
备份出来直接生成压缩后的备份文件
备份进度指示(估计值)
重新加载(还原)备份文件, 先建表后插入数据最后建立索引, 减少了索引维护开销, 加快了还原速度
备份可以排除或则指定数据库

示例

# mysqlpump 压缩备份 + 三个并发线程备份
mysqlpump -u user1 -p -h 192.168.1.20 --single-transaction \
    --default-character-set=utf8mb4 --compress-output=LZ4 \
    --default-parallelism=3 -B db1 > /home/user1/db1.sql.lz4

核心参数

绝大部分参数和 mysqldump 一致

差异部分


--add-drop-user
    在 CREATE USER 语句之前增加 DROP USER,
    注意: 这个参数需要和 --users 一起使用, 否者不生效
    DROP USER 'backup'@'192.168.123.%';


--default-parallelism
    指定并行线程数, 默认是 2, 如果设置成 0, 表示不使用并行备份;
    注意: 每个线程的备份步骤是:
    先 create table 但不建立二级索引(主键会在 create table 时候建立),
    再写入数据, 最后建立二级索引;

--defer-table-indexes
    延迟创建索引, 直到所有数据都加载完之后, 再创建索引, 默认开启;
    若关闭则会和 mysqldump 一样:
        先创建一个表和所有索引, 再导入数据,
        因为在加载还原数据的时候要维护二级索引的开销, 导致效率比较低;
    关闭使用参数 --skip--defer-table-indexes

--parallel-schemas=[N:]db_list
    指定并行备份的库, 多个库用逗号分隔,
    如果指定了 N, 将使用 N 个线程的地队列,
    如果 N 不指定, 将由 --default-parallelism 才确认 N 的值, 可以设置多个 --parallel-schemas

    mysqlpump --parallel-schemas=4:vs,aa --parallel-schemas=3:pt
        # 4 个线程备份 vs 和 aa, 3 个线程备份 pt;  通过 show processlist 可以看到有 7 个线程
    mysqlpump --parallel-schemas=vs,abc --parallel-schemas=pt
        # 默认 2 个线程, 即 2 个线程备份 vs 和 abc, 2 个线程备份 pt

    注意: 当然硬盘 IO 不允许的话, 可以少开几个线程和数据库进行并行备份


--compress-output
    默认不压缩输出, 目前可以使用的压缩算法有 LZ4 和 ZLIB

    shell> mysqlpump --compress-output=LZ4 > dump.lz4
    shell> lz4_decompress dump.lz4 dump.txt

    shell> mysqlpump --compress-output=ZLIB > dump.zlib
    shell> zlib_decompress dump.zlib dump.txt

--exclude-databases
    备份排除该参数指定的数据库, 多个用逗号分隔
    类似的还有:
    --exclude-events
    --exclude-routines
    --exclude-tables
    --exclude-triggers
    --exclude-users

    mysqlpump --exclude-databases=mysql,sys         # 备份过滤 mysql 和 sys 数据库
    mysqlpump --exclude-tables=rr,tt                # 备份过滤所有数据库中 rr, tt 表
    mysqlpump -B test --exclude-tables=tmp_ifulltext,tt # 备份过滤 test 库中的 rr, tt 表

    注意: 要是只备份数据库的账号, 需要添加参数 --users, 并且需要过滤掉所有的数据库, 如:
    mysqlpump --users --exclude-databases=sys,mysql,db1,db2 --exclude-users=dba,backup
        # 备份除 dba 和 backup 的所有账号

--include-databases
    指定备份数据库, 多个用逗号分隔, 类似的还有
    --include-events
    --include-routines
    --include-tables
    --include-triggers
    --include-users, 大致方法使用同 --exclude-users

--skip-definer
    忽略那些创建视图和存储过程用到的 DEFINER 和 SQL SECURITY 语句,
    恢复的时候, 会使用默认值, 否则会在还原的时候看到没有 DEFINER 定义时的账号而报错

--skip-dump-rows
    只备份表结构, 不备份数据, -d
    注意: mysqldump 支持 --no-data, mysqlpump 不支持 --no-data

--users
    备份数据库用户, 备份的形式是 CREATE USER..., GRANT...,
    只备份数据库账号可以通过如下命令:
    mysqlpump --exclude-databases=% --users    # 过滤掉所有数据库

--watch-progress        # 显示进度, 包括总数表, 行和其他对象;
--skip-watch-progress   # 关闭进度显示

--add-drop-database             # 在建立库之前先执行删库操作
--add-drop-table                # 在建表之前先执行删表操作

--add-locks
    备份表时, 使用 LOCK TABLES 和 UNLOCK TABLES
    注意: 这个参数不支持并行备份, 需要关闭并行备份功能 --default-parallelism=0

--complete-insert   # dump 出包含所有列的完整 insert 语句
--compress          # 压缩客户端和服务器传输的所有的数据, -C

--default-character-set     # 指定备份的字符集

--events    # 备份数据库的事件, 默认开启, 关闭使用 --skip-events 参数

--insert-ignore
    备份用 insert ignore 语句代替 insert 语句

--log-error-file
    # 备份出现的 warnings 和 erros 信息输出到一个指定的文件

--max-allowed-packet
    # 备份时用于 client/server 直接通信的最大 buffer 包的大小

--net-buffer-length
    备份时用于 client/server 通信的初始 buffer 大小,
    当创建多行插入语句的时候, mysqlpump 创建行到 N 个字节长

--no-create-db
    备份不写 CREATE DATABASE 语句;
    要是备份多个库, 需要使用参数 -B, 而使用 -B 的时候会出现 create database 语句,
    该参数可以屏蔽 create database 语句

--no-create-info
    备份不写建表语句, 即不备份表结构, 只备份数据, -t

--hex-blob
    备份 binary 字段的时候使用十六进制计数法,
    受影响的字段类型有 BINARY, VARBINARY, BLOB, BIT


--protocol={TCP|SOCKET|PIPE|MEMORY}             # 指定连接服务器的协议

--replace                                       # 备份出来 replace into 语句

--routines
    备份出来包含存储过程和函数, 默认开启, 需要对 mysql.proc 表有查看权限;
    生成的文件中会包含 CREATE PROCEDURE 和 CREATE FUNCTION 语句以用于恢复,
    关闭则需要用 --skip-routines 参数

--triggers
    备份出来包含触发器, 默认开启, 使用 --skip-triggers 来关闭

--set-charset
    备份文件里写 SET NAMES default_character_set 到输出, 此参默认开启;
    --skip-set-charset 禁用此参数, 不会在备份文件里面写出 set names...

--single-transaction
    该参数在事务隔离级别设置成 Repeatable Read,
    并在 dump 之前发送 start transaction 语句给服务端;
    这在使用 innodb 时很有用, 因为在发出 start transaction 时, 保证了在不阻塞任何应用下的一致性状态;
    对 myisam 和 memory 等非事务表, 还是会改变状态的,
    当使用此参的时候要确保没有其他连接在使用
        ALTER TABLE, CREATE TABLE, DROP TABLE, RENAME TABLE, TRUNCATE TABLE 等语句,
        否则会出现不正确的内容或则失败;
    --add-locks 和此参互斥,
    在 mysql5.7.11 之前, --default-parallelism 大于 1 的时候和此参也互斥,
    必须使用 --default-parallelism=0;
    5.7.11 之后解决了 --single-transaction 和 --default-parallelism 的互斥问题

--tz-utc
    备份时会在备份文件的最前几行添加 SET TIME_ZONE='+00:00'
    注意: 如果还原的服务器不在同一个时区并且还原表中的列有 timestamp 字段, 会导致还原出来的结果不一致;
    默认开启该参数, 用 --skip-tz-utc 来关闭参数

postgresql备份

chenwx716@139.com — Wed, 03 May 2023 22:12:48 +0800

逻辑备份与恢复

常用示例


# 备份
pg_dump --host hostname --port port -U user1 -d db1 -t t1 > table.sql

# 恢复
psql < dumpfile
psql -d sentry -U sentry -f dump1.sql
psql -h x.x.x.x -p 5432 -d db1 -U user1 -W pw -f xx.sql


# 恢复二进制备份
pg_restore -F non-plain-text-file

# 远程备份 + 恢复
pg_dump -h host1 dbname | psql -h host2 dbname

# 备份和恢复表结构和模式
pg_dump -U user1 -s db1 > backup.sql
psql -U user1 -d db1 -a -f backup.sql

逻辑备份恢复

错误处理
默认如果中途错误, psql 会继续执行，从而导致数据库只部分恢复

方法一: 错误退出
请设置 ON_ERROR_STOP 变量，使 psql 在发生 SQL 错误时退出，且有一个为 3 的退出状态码：
psql –set ON_ERROR_STOP=on dbname < dumpfile
方法二: 增加事务
指定整个转储作为一个事务来恢复，以便要么全部完成，要么全部取消
psql -1
pg_restore -e

恢复事项

createdb newDBname
确保所有拥有对象的用户或对转储数据库中的对象赋予了权限的用户都已存在;
如果这样的用户不存在, 恢复将无法重新创建具有原始所有权和权限的对象

pg_dump

转储单个数据库, 不会产生阻塞

备份目标对象: 文本, sql文件, 二进制文件

主要参数


-h  host
-p  port
-d  定义默认数据库

--inserts               导出表数据为 INSERT 语句, 默认为 COPY
--column-inserts        每个 INSERT 语句包含列名
-f --file file.sql      将输出保存到指定的文件

-j --jobs=              并行备份,并行粒度是表级别的

-n --schema=            指定模式, 可以多次使用
-N                      指定排除的模式, 可以多次使用

-t, --table=TABLE       指定表名, 可以指定多次
-T                      排除表名, 可以指定多次
--exclude-table         排除表

-x --no-privileges      不转储权限信息

-F --format=c|d|t|p     定义备份格式格式; custom | directory | tar| plain text
    plain 默认, 一个包含 SQL 命令的文本文件;
        不能并行恢复，恢复速度较慢

    custom 自定义格式是一种二进制格式，支持压缩
        不支持并行备份, 但并行恢复, 需要使用 pg_restore 工具来恢复
        支持数据压缩, 支持并行, 包含所有必要的元数据, 可以完整恢复数据库

    directory 新的备份格式, 支持更高级的并行备份和恢复
        支持并行, 二进制格式

    tar 单一文件, 支持压缩, 不支持并行
        生成的 .tar 文件可以使用标准的 tar 工具进行操作


-Z --compress=0-9       压缩级别

-b                      包含大对象

--lock-wait-timeout=    在等待表锁超时后失败

-O --no-owner           不指定对象的所有者
-a --data-only          仅导出表数据，不包括表结构和其他对象
-s --schema-only        只导出表结构(序列和索引等), 不包含数据

-c --clean              在重新创建前, 先删除对象
-C --create             在转储中包含命令, 以便创建数据库

-1 --single-transaction 作为单个事务进行

-w                      不提示输入密码
-W                      必须输入密码
-v                      输出详细信息

示例


# 一般备份库
pg_dump dbname > dumpfile

# 导出表结构
pg_dump -U user1 -s db1 > backup.sql
pg_dump -U user1 db1 -W -s -t t_name > t.sql

# 流式压缩和恢复, 避免文件过大磁盘空间不足的场景
pg_dump dbname | gzip > filename.gz
gunzip -c filename.gz | psql dbname

# 导出多个表, 多次指定 -t 选项
# 正则匹配
pg_dump -d db1 -n sam1 -U user1 -Fp -t"*_id_seq" -f"f:/mchshd1.sql" --inserts

pg_dump -d db1 -n sam1 -U user1 -t "sam1.dict_area" -Fp -f"f:/cdump" --inserts -x -v


# 定期执行全量备份
pg_dump -U user1 -d db1 -F c -b -f /backup/full_backup.backup

# 执行增量备份
pg_dump -U user1 -d db1 -F c -b -f /backup/incremental_backup.backup --data-only

pg_dump -h host -U user1 -F d -f backup_directory db1

pg_dumpall

转储给定集群中的每个数据库, 并保留集群范围的数据, 如角色和表空间定义

pg_dump 是不保留集群角色和表空间信息的

`1`	`pg_dumpall > dumpfile`

文本备份和恢复

即导出为 csv

1
2

# 导出表为 csv
\COPY t_name TO 'content-0429.csv' WITH CSV HEADER;

实例

# 备份 - 连接到数据库并执行 COPY 命令 - 导出数据没有 header 头
time psql -h database-1.xxxxx.ap-southeast-1.rds.amazonaws.com -p 5432 -U user1 -d db1 \
    -c "\COPY (SELECT * FROM public.tx WHERE user_send_time > '2025-10-21') TO 'tx10.csv' WITH CSV;"

# 删除新库多余数据
delete FROM public.tx WHERE user_send_time > '2025-10-21';
select count(1) FROM public.tx WHERE user_send_time > '2025-10-21';

# 恢复数据 - 指定第一行为头部
time psql -h me-master-1.xxxxx.ap-southeast-1.rds.amazonaws.com \
          -p 5432 -U user1 -d db1 \
          -c "\COPY public.tx FROM 'tx10.csv' WITH CSV HEADER;"

# 恢复数据 - 指定第一行为数据
time psql -h me-master-1.xxxxx.ap-southeast-1.rds.amazonaws.com \
          -p 5432 -U user1 -d db1 \
          -c "\COPY public.tx FROM 'tx10.csv' WITH CSV;"

pg_basebackup

特点

使用的使用复制协议
v17+ 支持增量备份

前提: 因为是复制协议, 所以需要权限

# 需要创建 replication 权限的角色, 或者超级用户的角色;
create role repl nosuperuser replication login connection limit 32 encrypted password '111111';

# hba.conf
host replication repl 0.0.0.0/0 md5

实例

# 并行备份
pg_basebackup -j 4 -D /path/to/backup

# 远程备份
pg_basebackup -F t -x -D /home/postgres/bak/`date +%F` -h 192.168.1.2 -p 5432 -U repl


# 增量备份

先执行一个全量备份
pg_basebackup -D /data1/fullbackup/ -Ft -R -Xs -Pv

再执行一个增量备份
pg_basebackup -D /data1/incrbackup/ -Ft -R -Xs -Pv -c fast -i /data1/fullbackup/backup_manifest

-- 合并全量和增量备份(只能对平文本备份进行合并,因此需要先解包或者直接进行Fp备份)
pg_combinebackup /data1/fullbackup /data1/incrbackup -o /data1/combinebackup/

参数解析

pg_basebackup -D /postgresql/backup/full_$(date +%Y%m%d_%H%M) -h localhost -p 5432 -U postgres \
    -F tar -X stream -P -v -z --checkpoint=fast

-F tar             # tar格式便于传输和存储
-X stream          # 并行流式传输WAL日志
-P                 # 显示实时进度
-v                 # 详细输出
-z                 # gzip压缩
--checkpoint=fast  # 快速检查点减少业务影响
-X 表示备份开始后, 启动另一个流复制连接从主库接收 WAL 日志

--pgdata=/data/pg_data
--waldir=/data/pg_wal
--write-recovery-conf
--progress
--verbose

pg_restore

适合来并行恢复备份, 需要是支持并行恢复的二进制格式的备份

在恢复大量数据前，将 maintenance_work_mem 和 work_mem 设置为更高的值，能提高索引和约束的创建速度

pg_restore [选项] [备份文件] [--dbname=<数据库名>]

-F  指定文件
-Ft 指定 tar 格式的文件
-Fp 指定 plain 文本格式的文件
-c  还原前清空库
-O  不还原所有者
-j  并行度
-n  指定还原的 模式
-t  指定还原的 表
-d  指定还原的 库

--data-only     只恢复数据

pg_waldump

1
2

# 查看 redolog 内容
pg_waldump pg_wal/000000010000000000000002

归档备份与恢复

备份方式

定期全量备份
配置归档策略 - 保存归档日志

恢复方式

从数据库的全量备份目录启动, 检测到以恢复模式启动
读取和应用 pg_wal 目录下的 wal 文件
如果缺失 wal 文件, 就执行 restore_command 命令拷贝 wal 文件

备份配置

# 配置基于 WAL(预写日志)的连续归档机制 - 增量备份

# 启用归档模式(需重启数据库生效)
archive_mode = on

# WAL 日志的保留策略(确保归档完成前不被覆盖)
# 推荐设置为: max_wal_senders + 1(流复制场景)或根据归档速度调整
wal_keep_size = 1GB  # 或使用 wal_keep_segments(旧版本, 单位: 8KB 块)

# 归档命令: 将 WAL 文件 拷贝走, 注意归档目录的权限
# %p: 当前 WAL 文件的路径(相对 $PGDATA)
# %f: 当前 WAL 文件的文件名
archive_command = 'cp %p /path/to/archive/%f'  # 基础示例(本地归档)

# 生产环境推荐: 使用 rsync 同步到远程存储, 或结合脚本确保归档成功
# archive_command = 'rsync -a %p user@backup-server:/path/to/archive/%f'

管理命令


select pg_switch_wal();         # 手动触发 wal 文件切换

# 查看归档文件
SELECT * FROM pg_stat_archiver;

创建基础全量备份

# 创建基础备份
pg_basebackup -D /backup/pg_basebackup -Fp -P -R
pg_basebackup -D /data/base_backup/$(date +%Y%m%d) -Fp -Xs

# 常用参数:
# -D: 备份目录
# -Fp: 纯格式(文件系统格式)
# -Ft: tar 格式
# -P: 显示进度
# -R: 创建恢复配置
# -X: WAL 日志包含方式

恢复数据流程

stop db
将完整备份替换到现在的数据库位置
创建 recovery.signal 文件, 告知 PostgreSQL 启动时进入恢复模式
启动数据库, 会进入恢复模式(只读)
恢复模式中会自动读取 wal 文件并应用; restore_command
确认数据恢复完全后, 结束恢复模式, 允许数据写入

示例

# 切换到 postgres 用户或实际用户进行操作, 避免权限问题
su - postgres

# 在数据目录创建 恢复触发文件 (版本 v12 之前使用 recovery.conf)
touch $PGDATA/recovery.signal

vi /var/lib/pgsql/14/data/postgresql.conf
更推荐这个文件 $PGDATA/postgresql.auto.conf 文件中设置恢复目标
如果知道确切时间, 使用 recovery_target_time:

# 设定恢复 wal 文件的命令, 从归档目录读取 WAL 日志用于重放事务
restore_command = 'cp /path/to/archive/%f %p'

# 可选: 指定恢复到特定时间点(按需配置, 不配置则恢复到最新), 支持 ='latest'
recovery_target_time = '2025-11-10 10:00:00'

# 可选: 指定恢复到特定 WAL 位置
recovery_target_lsn = '0/1234ABCD'

# 可选: 包含目标时间点
recovery_target_inclusive = true


# 启动数据库服务, 并实时查看日志, 观察恢复过程
$ pg_ctl -D $PGDATA start -l recovery.log
waiting for server to start.... done
server started

tail -f recovery.log

# 检查恢复后的数据
postgres=# select * from tx;


# 结束恢复模式并允许写入
SELECT pg_wal_replay_resume();

mongo工具

chenwx716@139.com — Fri, 10 Feb 2023 10:00:00 +0800

备份-恢复

备份

# 备份库
mongodump -d meuat -o /data/db/backup/meuat-2025-0408

# 备份单表
mongodump -d prod -c t_new_delegation -o ./backupdb/table/

恢复

# 恢复库
mongorestore -d meuat /tmpdata/meuat-2025-0408/meuat

# 恢复前删除
mongorestore -d test --drop /bak/mongodump/*

# 指定恢复单个集合到另一个库
mongorestore --uri="mongodb://admin:admin123456@localhost:27017/" \
             --drop \
             --nsFrom="db1.t_msg_account" \
             --nsTo="mepro.t_msg_account" \
             /data/tmpdata/bk1/db1/t_msg_account.bson

用户

mongo --host 10.27.10.83 --port 27017 -u bunnyc -p --authenticationDatabase=bunnycdb
mongo --host 10.27.10.83 --port 27017 -u bunnyc -p 'passw0rd' --authenticationDatabase=bunnycdb



use bunnycdb
db.auth("bunnyc","Fcdseicx_f32")

综合

> show dbs              # 查看存在的数据库
> show collections      # show 集合

# 查看表字段
db.me_contact_talk_history.findOne()

# 查看表字段 - 全
db.me_contact_talk_history.aggregate([
  { $project: { _id: 0, fields: { $objectToArray: "$$ROOT" } } },
  { $unwind: "$fields" },
  { $group: { _id: null, allFields: { $addToSet: "$fields.k" } } }
])

检查和监控

mongostat --port 27017 -u myadmin -p 123456 --authenticationDatabase=admin

# 抓取当前正在执行中的 sql
db.currentOp()

# 查看耗时超过 1 秒的操作
db.currentOp({ "secs_running": { "$gt": 1 } });

# 查看运行时间超过 单位为微秒
db.currentOp({ "microsecs_running": { "$gt": 100000 } });

数据

db.t_name.find()
db.t_host.find({"mess_code":1001})

db.local('/tmp/file.json')      // 执行文件

db.t_name.remove()
db.t_name.drop()

索引

// 查看表的索引
db.t_name.getIndexes();

// 创建联合索引
db.t_name.createIndex({ fromAddr: 1, toAddr: 1, address: 1 })

// 创建单字段索引
db.t_name.createIndex({ address: 1 })

// 后台创建索引 - 避免阻塞
db.t_name.ensureIndex({address:1},{background:true})

// 查看索引
db.t_name.getIndexes()

// 查询文档上的索引 - 名称
db.t_name.getIndexes().forEach(function(index) {
    printjson(index.name)
})

停服

1
2
3

use admin
db.auth("root","passw0rd")
db.shutdownServer();

复杂查询

匹配条件

# sql 条件
$eq:        等于指定值
$ne:        不等于指定值
$gt:        大于指定值
$gte:       大于或等于指定值
$lt:        小于指定值
$lte:       小于或等于指定值
$in:        在指定数组中
$nin:       值不在指定数组中
$exists:    匹配包含指定字段
$type:      匹配指定数据类型
$regex:     使用正则表达式匹配字段值的文档
$not:       取反
$and
$or

简单查询

db.getCollection("t1").find({'address': 'aaaaa'});

db.t_name.find({"ip":"10.26.2.20", "cpu":{$gt:20}})
db.t_name.find({field:{$gt:value}});
db.t_name.find({"cpu_rate":{$gt:9}}).count()

db.t_name.remove({height: {$gt:5251149}})       // 删除大于指定高度的记录

复杂查询

// 统计数量
db.t_name.count()
db.t_name.find().count()

db.t_name.find().limit(1)                   // 查询第一条
db.t_name.find().sort({_id: -1}).limit(1)   // 查询最新一条

db.t_name.find({condition: "value"}).limit(1)   // 过滤后的第一条

db.t_name.find().sort({field: 1}).limit(1)  // 排序后的第一条

db.t_name.findOne()                         // 函数查询第一条
db.t_name.findOne({condition: "value"})     // 函数查询第一条-条件

// 按指定字段排序 - 取最大的值的一行
db.t_name.find().sort({ txs: -1 }).limit(1)

// 按指定字段排序 - 取最大的值的一行
db.t_name.aggregate([
    { $sort: { txs: -1 } },
    { $limit: 1 }
])

按日期分组统计

var results = db.t_name.aggregate([
    {
        $group: {
            _id: { $dateToString: { format: "%Y-%m-%d", date: "$timestamp" } },
            count: { $sum: 1 }
        }
    },
    {
        $sort: { _id: 1 }
    }
]).toArray();

results.forEach(function(result) {
    printjson(result);
});

遍历集合

// 获取当前数据库的所有集合名称
var collections = db.getCollectionNames();

// 遍历每个集合
collections.forEach(function(collectionName) {
    // 获取当前集合
    var collection = db.getCollection(collectionName);

    // 查询集合中是否存在包含`height`字段的文档
    var hasHeightField = collection.find({"height": {$exists: true}}).count() > 0;

    // 如果存在`height`字段，打印集合名称
    if (hasHeightField) {
        print("Collection with 'height' field: " + collectionName);
    }
});

mysql常用命令

chenwx716@139.com — Fri, 10 Feb 2023 10:00:00 +0800

备份

1. 逻辑备份


# 备份单库
mysqldump -u root -p -B db1 \
    --master-data=2 --single-transaction --flush-logs > db1-2020-05-09.sql

mysqldump -u wait -p \
    --single-transaction \
    --set-gtid-purged=OFF --databases db1 > local_wp.sqk


# 备份表结构
mysqldump -u root -p -d --add-drop-table db1 > 2020-05-11_db1.sql

mysqldump -u root -p --set-gtid-purged=OFF me_data_move > 0805-me_data_move.sql

# 只导出 insert 语句, 不生成创建表的动作
mysqldump --no-create-info db1 t1 t2 t3 > t_123.sql

# 备份 多个库
mysqldump -u root -p --set-gtid-purged=OFF -B db1 db2 db3 > 0806-all.sql

# 备份多个库
mysqldump -h db-xxx-uat.xxxx.ap-southeast-1.rds.amazonaws.com -P 13306 -u admin -p \
  --databases db1 db2 db3  > uat-db-20240813.sql

2. 逻辑恢复

# 恢复数据
mysql -u root -p < 0806-all.sql

# 恢复数据
mysql -u root -p $db_pw -S /data/mysql_13306/mysql.sock  < newsql.sql

对象管理

用户


-- 创建用户
CREATE USER 'user1'@'10.255.10.%' identified by 'passw0rd';

-- 早期方式
CREATE USER 'user1'@'10.255.10.%' IDENTIFIED WITH mysql_native_password;
grant all on db1.* to user1@'10.255.246.%' identified by '123456';

-- 删除用户
delete from user where user='user1' and host='10.255.246.%';

-- 刷新权限
flush privileges;

-- 查看权限
show grants for user@'%';

-- 授权
GRANT ALL ON *.* TO 'wait'@'%';

-- 修改密码
alter user 'root'@'localhost' identified by 'passw0rd';


set password=password('KdpTkiChO0MD!U&jyV@R');
-- 修改当前用户的密码

-- 单独设定指定用户的的连接数
ALTER USER 'root'@'%' WITH MAX_USER_CONNECTIONS 100;

实例


# 临时启动数据库
nohup mysqld_safe --defaults-file=/home/wait/mysqldb/my.cnf &

# 停止服务
mysqladmin -u root -p -P 3306 shutdown


# 关闭数据库 - 对于 mysqld_safe 启动的情况
mysqladmin -u root -p -S mysqldb/mysql.sock shutdown

-- 临时设置为只读 - 所有库
set read_only=on;
set super_read_only=on;

-- 临时配置
set global sync_binlog=0;
set global innodb_flush_log_at_trx_commit=0;
set global max_connections=8000;

PERSIST修改持久化

-- 持久化修改系统变量
-- 8.0+ 的 persist 将修改会持久化到临时文件中, 重启有效, 自动写入 mysqld-auto.cnf 文件
SET PERSIST max_connections = 200;

set persist read_only=on;
set persist super_read_only=on;

SET PERSIST_ONLY max_connections = 200;     -- 只持久化, 重启才生效

-- 清空持久化的配置
-- 只是清空 mysqld-auto.cnf 和 performance_schema.persisted_variables 中的内容
reset persist

库

show databases;               -- 显示所有数据库
use dbname;                   -- 进入数据库

create database if not exists localtest character set 'utf8mb4';


drop database db1;           -- 删除数据库

表

show tables;                  -- 显示all表

--- 修改表结构
alter table tablename modify id int(10) not null primary key auto_increment;

truncate table t_name;
drop table t_name;

desc tables;                    -- 查看表结构
show create table t_1;          -- 查看表 DDL


CREATE TABLE t1 (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(20),
    owner VARCHAR(20),
    sex CHAR(1),
    birth DATE
);

CREATE TABLE `t_test` (
    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
    `time` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '入库时间',
    `key` VARCHAR(50) NOT NULL COMMENT '名称',
    `num` INTEGER NOT NULL default '0',
    `body` VARCHAR(50) NOT NULL COMMENT '名称'
);

-- 生成 TRUNCATE 全部表的 sql
SELECT CONCAT('TRUNCATE TABLE ', table_name, ';')
FROM information_schema.tables
WHERE table_schema = 'db1';

慢查询

1
2

-- 测试慢查询是否成功记录
select sleep(6);

开启审计日志

记录每一条sql, 开销比较大, 临时 debug

SET GLOBAL general_log = 1;

-- 查看审计日志文件路径
show variables like 'general%log%';

事务


-- 查看是否开启自动提交
show global variables like '%autocommit%';

-- 查看运行中的事务详细信息
select * from information_schema.INNODB_TRX \G;

-- 查看事务线程id和客户端信息
show processlist

-- 关闭某个线程id
kill 469273630

客户端

# 之后所有查询都会写入此文件
mysql> pager cat > /tmp/test.txt;

# login-path 设置快速登录
mysql_config_editor set --login-path=logdb --user=user1 --host=10.27.10.10 --port=3306 --password

mysql_config_editor print --all

mysql_config_editor remove --login-path=logdb

mysql --login-path=logdb    # 快捷登录

巡检

基础检查

select version();
show global status like 'uptime';   -- 查看运行时长
show databases;         -- 显示所有数据库
show processlist;       -- 查看会话信息
show warnings;          -- 查看最近的报错信息
show variables;         -- 查看所有参数变量
show global variables;
show global status;     -- 状态

show engine innodb status\G

网络

-- 连接数设置
show global variables like '%max_connect%';
show global variables like 'thread_cache_size%';     -- 线程池设定大小

show status like 'Connections';         -- 启动以来的连接总次数
show status like 'threads%';
SHOW GLOBAL STATUS LIKE 'Threads_connected';    -- 查看活跃连接数

-- 查看 root 用户的最大连接数量, - 如果为0则使用全局配置
SELECT USER, HOST, MAX_USER_CONNECTIONS FROM mysql.user WHERE USER = 'root';

-- 活跃用户 - 排除repl
select count(1) from processlist where state <> '' and user <> 'repl' and time > 2;

select * from socket_instances;
select * from performance_schema.users;
select * from performance_schema.hosts;

mysql> show status like 'threads%';
+-------------------+-------+
| Variable_name     | Value |
+-------------------+-------+
| Threads_cached    | 3     |       # 此刻已经建立的线程中有多少空闲线程
| Threads_connected | 807   |       # 当前已经建立的连接数
| Threads_created   | 810   |       # 代表从最近一次服务启动，已创建线程的数量
| Threads_running   | 2     |       # 代表当前激活的（非睡眠状态）线程数

IO-存储

mysql> show variables like 'log_bin';
mysql> show variables like 'sync_binlog';
mysql> show variables like 'innodb_flush_log_at_trx_commit';

SHOW GLOBAL VARIABLES LIKE 'open_files_limit';
SHOW GLOBAL VARIABLES LIKE 'flush';
SHOW GLOBAL VARIABLES LIKE 'sort_buffer_size';
SHOW GLOBAL VARIABLES LIKE '%buffer_size%';

show variables like 'innodb_commit_concurrency';
show variables like 'innodb_page_cleaners';
show variables like '%page_cleaner%';

SHOW GLOBAL VARIABLES LIKE 'innodb_buffer_pool_instances';
SHOW GLOBAL VARIABLES LIKE 'innodb_io_capacity';
SHOW GLOBAL VARIABLES LIKE 'innodb_lru_scan_depth';

库表查询

-- 查看数据库大小
SELECT
    table_schema AS '数据库名',
    ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS '大小(MB)',
    ROUND(SUM(data_length) / 1024 / 1024, 2) AS '数据大小(MB)',
    ROUND(SUM(index_length) / 1024 / 1024, 2) AS '索引大小(MB)'
FROM information_schema.tables
GROUP BY table_schema
ORDER BY SUM(data_length + index_length) DESC;


-- 查看数据库大小 - 含表数量
SELECT
    table_schema AS 'Database',
    COUNT(*) AS 'Tables',
    ROUND(SUM(data_length) / 1024 / 1024, 2) AS 'Data Size (MB)',
    ROUND(SUM(index_length) / 1024 / 1024, 2) AS 'Index Size (MB)',
    ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS 'Total Size (MB)',
    ROUND(SUM(data_free) / 1024 / 1024, 2) AS 'Free Space (MB)'
FROM information_schema.tables
WHERE table_schema NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys')
GROUP BY table_schema
ORDER BY SUM(data_length + index_length) DESC;


-- 查询表行数 和 数据大小 和 索引大小
SELECT table_schema, table_name, table_rows,
    data_length/1024/1024 as SIZE_T_MB,
    index_length/1024/1024 as SIZE_I_MB
FROM information_schema.tables WHERE table_schema = 'mytest';


-- 查询自增id的使用情况
select
    table_schema,table_name,engine,Auto_increment
from
    information_schema.tables
where
    INFORMATION_SCHEMA.tables.TABLE_SCHEMA not in ("information_schema","performance_schema","sys","mysql");

故障处理

`1`	`mysql -uroot -p -e "show processlist" \|grep -v Sleep`

`1`	SELECT * FROM information_schema.`PROCESSLIST` WHERE command != "Sleep" ORDER BY time DESC;

结束阻塞任务

-- 生成 kill 执行时间超过 5 分钟的sql
SELECT
    concat( 'kill ', id, ';' )
FROM
    information_schema.PROCESSLIST
WHERE
    command != 'Sleep'
    AND time > 5 * 60
ORDER BY
    time DESC;

-- 查看当前未关闭的事务
select * from information_schema.INNODB_TRX \G;

sql语句

插入更新删除

INSERT INTO t1 VALUES ('cwx', 'chenwx', 'n', '1990-03-30');

insert into tablesname(字段1,字段2,字段3) values(值,值,值);
insert into tablesname(字段1,字段2,字段3) values(值,值,值),(值,值,值),(值,值,值);

UPDATE t1 SET name = 'cwx1' where owner = 'chenwx';

DELETE FROM t1 where name = 'cwx';

简单示例

select * from t_name limit 5;

-- 去重显示(即每项目只显示一次)
SELECT DISTINCT c1 FROM teacher;


-- 多查询
SELECT * FROM t1 WHERE degree IN (85, 86, 88);

-- 区间查询
SELECT * FROM t1 WHERE degree BETWEEN 60 AND 80;
SELECT * FROM t1 WHERE degree > 60 AND degree < 80;

-- 按月分组
SELECT DATE_FORMAT(insert_time,'%Y%m') months,count(id) from t1 group by months;

-- 分渠道去重
select  t.spid,count(distinct t.login_name) from t1 t group by t.spid;


-- 子查询
select name,math from t1 where math=(select max(math) from t1);
select a,b,c from a where a IN (select d from b where c='3');

select a.name from
    (select * from table_name where classess="数学") a,
    (select * from table_name where classess="语文") b
    where a.court<b.court and a.name=b.name;

-- 统计
SELECT
    SUM(CASE WHEN is_logoff = 0 THEN 1 ELSE 0 END) AS 有效用户,
    SUM(CASE WHEN is_logoff = 1 THEN 1 ELSE 0 END) AS 注销用户
FROM
    t_user;

较复杂


-- 查询重复行
SELECT ctime, COUNT(*) AS count FROM t1 GROUP BY ctime HAVING COUNT(*) > 1;

-- 列出重复行
SELECT * FROM t1 WHERE ctime IN (SELECT ctime FROM t1 GROUP BY ctime HAVING COUNT(*) > 1);


-- 查找具有重复 code 值的条目
select * from products group by code having count(code)>1;
    -- 按 group by 分组后, 就已经完成了合并
    -- having count(code)>1  表示过滤出数量大于 1 条的内容

-- 查找重复的数据
select * from t_host_info where 1=1 group by random_num having count(random_num) >1;

转换

-- 类型转化
CAST(t.body AS CHAR)

inet_aton()     -- 将ip地址转换成数字型 10.1.249.55 -> 167901495
inet_ntoa()     -- 将数字型转换成ip地址

主从

show master status;         -- 查看当前binlog位置
show slave status\G         -- 查看复制状态
show master logs;           -- 查看 binlog 文件
flush logs;                 -- 轮转binlog日志

-- 清理之前的 binlog
PURGE MASTER LOGS TO 'mysql-binlog.000336';

reset master;

-- 查看跳过错误的配置
show variables like 'slave_skip_errors';

show variables like '%gtid%';

-- 创建
CHANGE MASTER TO
  MASTER_HOST='10.2.1.5',
  MASTER_PORT=3306,
  MASTER_USER='sync',
  MASTER_PASSWORD='passw0rd',
  GET_MASTER_PUBLIC_KEY=1,              -- 8.x 非 ssl 同步时需要获取公钥
  MASTER_LOG_FILE='binlog.000022',
  MASTER_LOG_POS=476432;

`1`	`mysql -u root -p -e "show slave status\G;" \| grep _Running`

nosql-工具箱

chenwx716@139.com — Fri, 10 Feb 2023 10:00:00 +0800

etcd

# 创建快照备份
export ETCDCTL_API=3
etcdctl --endpoints localhost:2379 snapshot save snapshot.db \
          --cacert=/etc/kubernetes/pki/etcd/ca.crt  \
          --cert=/etc/kubernetes/pki/etcd/server.crt \
          --key=/etc/kubernetes/pki/etcd/server.key

# 快照恢复命令
etcdctl snapshot restore snapshot.db --name m3 --data-dir=/home/etcd_data

memached

# run
memcached -d -p 39001 -m 30 -P memcached.pid

# 清空缓存
echo flush_all | nc 10.2.1.5 21101

# show
echo stats | nc 10.2.1.5 21101
echo stats | nc 10.2.1.5 21101 | grep curr_connections

# 查看 lru 淘汰的key数量
echo stats | nc 10.2.1.5 21101 | grep evictions

# get
echo -ne "get key_name\r\n" | nc 10.2.1.5 21101

# del
echo "delete jtsysconfig_traffic_control_config_12028" | nc 10.2.1.5 21101

# set
printf "set key008 0 5 10\r\noldboy0987\r\n"|nc 10.2.1.5 11211

set wait 0 180 9
chenwx716

consul


consul acl set-agent-token default 0bc6bc46-f25e-4262-b2d9-ffbe1d96be6f

consul agent -dev

consul agent -config-dir config

consul agent -server -bootstrap -bind=127.0.0.1 -client=127.0.0.1 -node=redis1 \
    -config-dir conf -enable-script-checks -data-dir=data -ui -node=127.0.0.1


http://127.0.0.1:8500

consul.exe agent -server -bootstrap-expect 1 \
    -data-dir "D://app//consul_1.11.2//data" \
    -advertise 127.0.0.1 -ui -node=node1 \
    -bind 127.0.0.1 -client 0.0.0.0 -rejoin -config-dir "D://app//consul_1.11.2//config"

es


curl 'http://localhost:9200/_cat/indices?v'

# 获取全部数据，默认只显示10条
curl -XGET 'http://localhost:9200/index-name/doc-type/_search?pretty'

# 根据ID查询数据
curl -XGET 'http://localhost:9200/index-name/doc-type/id?pretty'

# 查询条件，参数 q=
curl -XGET 'http://localhost:9200/megacorp/employee/_search?q=name:Smith'

curl -XGET 'http://localhost:29200/nginx_access/_search?q=x_forwarded_for:117.136.38.182&pretty'

# del index
curl -X DELETE "http://localhost:19200/indexName?pretty"'&timeout=5m'

# 时间范围数量统计
curl -XGET 'http://10.27.10.30:29200/cd-nginx-2020.11.01/_count?pretty' \
-H 'content-type: application/json' -d '
{
  "query": {
    "range":{
      "@timestamp":{
        "gte": "2020-11-01 10:00:00",
        "lte": "2020-11-01 11:00:00",
        "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd",
        "time_zone": "+08:00"
      }
    }
  }
}'

kibana

常用查询语句

1
2

# 指定路径+耗时范围
request_uri:"/services/LoginForApp" AND request_time:[0.500 TO 9.000]

redis

慢查询


slowlog get                                     # 查询慢查询记录

# 配置
config set slowlog-log-slower-than 1000         # 1ms
config set slowlog-max-len 500
CONFIG GET slowlog-*                            # 获取配置

客户端

# 连接集群
redis-cli --cluster 10.27.10.1 21101
redis-cli --cluster -p 21101
redis-cli -c -h 10.27.10.1 -p 11102
redis-cli -c -h 192.168.0.1 -p 6389 -a password

数据管理

FLUSHALL                # 清空所有库
FLUSHDB                 # 清空单个库 - 当前库

DBSIZE                  # show key number
TTL key                 # 获取key的剩余过期时间s

监控

redis-cli MONITOR

MONITOR
INFO
STATS

CLUSTER info
CLIENT LIST
cluster nodes

集群管理

# 添加从节点
./redis-cli --cluster add-node <新节点> <连接的主节点> --cluster-slave --cluster-master-id <主节点ID>

./redis-cli --cluster add-node 10.1.99.91:16483 10.1.99.70:16379 --cluster-slave --cluster-master-id feb7b92d1a183b14e5528c667e58592d8131057b

sqlite

.databases              # show current db
.tables                 # show all tables
.indices [table]        # 获取表的索引列
.schema [table]         # 显示表结构 DDL

# 非交互查询
sqlite3 test.db "sleect * from t_file"

oracle

chenwx716@139.com — Fri, 10 Feb 2023 10:00:00 +0800

比较陈旧, 12c 之后就没有再接触过 oracle

系统管理

# 监听管理
lsnrctl status
lsnrctl start
lsnrctl stop

# 管理员登陆
sqlplus / as sysdba

# 起停库
SQL> shutdown immediate;
SQL> startup

# sqlplus login
sqlplus wait/passw0rd
sqlplus wait/passw0rd@10.2.1.65/orcl
sqlplus 'user1/"passwd"'@10.1.249.45/sso_test    # 特殊密码字符密码

对象管理

表

desc table_name;                -- 查看表 DDL 语句

-- 删除指定的表
drop table t1;
drop table t1 purge;

truncate table table_name;

--- 查询表大小
select round(BYTES/1024/1024,2)||'M' from user_segments where segment_name='t_table';
select sum(round(BYTES/1024/1024,2)) from user_segments where segment_name='t_table';

表空间

--- 查询表空间的使用率(集合查询)
select
    a.tablespace_name,
    a.bytes/1024/1024 "Sum MB",
    (a.bytes-b.bytes)/1024/1024 "used MB",
    b.bytes/1024/1024 "free MB",
    round(((a.bytes-b.bytes)/a.bytes)*100,2) "percent_used"
from
    (select tablespace_name,sum(bytes) bytes from dba_data_files group by tablespace_name) a,
    (select tablespace_name,sum(bytes) bytes,max(bytes) largest from dba_free_space group by tablespace_name) b
where
    a.tablespace_name=b.tablespace_name
order by
    ((a.bytes-b.bytes)/a.bytes) desc

锁


--- 查看表锁
SELECT l.session_id sid,
       s.serial#,
       l.locked_mode 锁模式,
       l.oracle_username 登录用户,
       l.os_user_name 登录机器用户名,
       s.machine 机器名,
       s.terminal 终端用户名,
       o.object_name 被锁对象名,
       s.logon_time 登录数据库时间
FROM v$locked_object l, all_objects o, v$session s
WHERE l.object_id = o.object_id
   AND l.session_id = s.sid
ORDER BY sid, s.serial#;

--- 查看详细的锁信息
SELECT l.session_id sid,
       s.serial#,
       l.locked_mode 锁模式,
       l.oracle_username 登录用户,
       l.os_user_name 登录机器用户名,
       s.machine 机器名,
       s.terminal 终端用户名,
       o.object_name 被锁对象名,
       o.object_type 被锁对象类型,
       s.logon_time 登录数据库时间,
       a.sql_text 当前执行的语句
FROM v$locked_object l, all_objects o, v$session s,v$sqlarea a
WHERE l.object_id = o.object_id
   AND l.session_id = s.sid
   AND s.prev_sql_addr = a.address
ORDER BY sid, s.serial#;

dg


-- oracle dg
SELECT substr((SUBSTR(VALUE,5)),0,2)*3600 + substr((SUBSTR(VALUE,5)),4,2)*60 + substr((SUBSTR(VALUE,5)),7,2) AS seconds, VALUE
FROM v$dataguard_stats a
WHERE NAME ='apply lag'

数据库

巡检

-- 看数据库链接数
select count(*) from v$process;

--- 并发连接数
select count(*) from v$session where status='ACTIVE';

-- 查看当前数据库建立的会话情况
select count(*) from v$session;
select sid,serial#,username,program,machine,status from v$session;
select count(*) from v$session where username not in('SYS','SYSTEM') and username is not null and STATUS='ACTIVE';
    -- 活跃普通用户

select name,value from v$parameter
select name,value value from v$sysstat

-- 查看对象的创建时间
SELECT CREATED FROM USER_OBJECTS WHERE OBJECT_NAME='TABLE';

show parameter pga_aggregate_target                 -- 看 PGA 大小
show parameter sga_%                                -- 看 SAG 大小
show parameter processes;                           -- 查看当前连接数设置
select userenv('language') from dual;               -- 查询字符集
select tablespace_name from dba_tablespaces;        -- 查询已有的表空间
select * from dba_directories;                      -- 查看数据库目录变量

select * from dba_users;                            -- 列出系统中所有用户
select table_name from user_tables;                 -- 查看当前用户在数据库下的表
select instance_name from v$instance;               -- 查看实例名


select segment_name, sum(bytes)/1024/1024 Mbytese from user_segments group by segment_name;
--- 查询用户表、索引、分区表所占用的空间

select segment_name, sum(bytes)/1024/1024 Mbytese from user_segments where segment_type='TABLE' group by segment_name;
--- 用户表空间占用

select segment_name,sum(bytes)/1024/1024 Mbytes from user_segments where segment_type='TABLE PARTITION' group by segment_name;
--- 分区表空间占用

--- 查询定时作业任务的执行情况
select job,log_user,last_date,failures from dba_jobs;

--- 查询数据文件的有效性
select file_name,status from dba_data_files;

查询语句

select
    c.ip,
    -- 求某个值出现次数的一种方法
    sum(case when c.result='0' then '1' else '0' end) login_sum
from xxxx c;

postgresql工具箱

chenwx716@139.com — Fri, 10 Feb 2023 10:00:00 +0800

备份-恢复

备份-pg_dump

export PGPASSWORD='user123456'

# pg_dump 逻辑备份工具, 支持二进制导出

# 关键参数
-O      不指定对象的所有者
-c      在重新创建前, 先删除对象
-x      不转储权限信息
-F d    目录存储
-b      二进制
-f      指定位置

# 普通逻辑备份
pg_dump -h 172.27.0.50 -U user1 -d db1 > db1.sql

# 备份表结构
pg_dump -U user1 -s db1 > db1_table_info.sql

# 不包括权限和属主信息, 包括删除对象的操作
pg_dump -U user1 -d db1 -x -O -c -f db1.sql

# 二进制, 目录格式 - 推荐
pg_dump -U user1 -d db1 -F d -b -c -f /backup/db1-20250904-1431
pg_dump -U user1 -d db1 -F d -b -x -O -c -f /backup/db1-20250904-1431

# 备份时并忽略指定表
pg_dump -U user1 -d db1 -O -x -c \
    --exclude-table-data=pre_commit \
    --exclude-table-data=tm_validators -f pro_db1.sql

恢复-逻辑恢复

`1`	`psql -U user1 -d db1 -f 08281925_data.sql`

管理

用户

`1`	`create user user1 with password 'passw0rd';`

库


-- 创建库并赋权限
CREATE DATABASE db1;
GRANT ALL PRIVILEGES ON DATABASE db1 TO user1;


-- 查看数据库大小
SELECT pg_size_pretty(pg_database_size('me_hub'));

SCHEMA

`1`	`DROP SCHEMA myschema CASCADE; -- 删除模式和其下的对象`

客户端


# 查看数据库列表
psql -Upostgres -c '\l'


# 主机上安装不了高版本 psql 时, 使用 docker  客户端
docker run --name rds_tmp_task1 --rm -it \
    -e "PGPASSWORD=user123456" \
    -v /backup:/backup \
    -v /root/tmp:/tmpdata postgres:17.4 \
    psql -U user1 -d db1 -h database-1.xxxxxx.ap-southeast-1.rds.amazonaws.com

# login_db_me_rds.sh
export PGPASSWORD=user123456
psql -U user1 -d db1 -h database-1.xxxxxx.ap-southeast-1.rds.amazonaws.com


# 非交互式执行 sql

export PGPASSWORD=user123456
psql -h 192.168.0.206 -p 15432 -U user1 -d db1 -f drop_table.sql

echo ${SQL_TXT} | psql -h 192.168.0.206 -p 15432 -U user1 -d db1 -f -

dsn

1
2


dsn: postgres://user1:password@192.168.0.26:5432/db1?sslmode=disable

配置

1
2
3


-- 查看关键配置参数
select name,setting from pg_settings where name in ('max_wal_size','min_wal_size','wal_segment_size','wal_keep_size','wal_level','wal_buffers','fsync');

数据

基础语句

# 不换行输出
\pset pager off

# 不换行输出 方法2/3
export PAGER=cat
psql -c "SELECT * FROM your_table" -P pager=off

# 输出查询
\o output.txt

tables

-- 清空全部表
DO
$$
DECLARE
    table_name text;
BEGIN
    FOR table_name IN (SELECT tablename FROM pg_tables WHERE schemaname = 'public')
    LOOP
        EXECUTE 'TRUNCATE TABLE "' || table_name || '" CASCADE';
    END LOOP;
END
$$
;

-- 删除 all 表, 有删除依赖对象
DO
$$
DECLARE
    table_name text;
BEGIN
    FOR table_name IN (SELECT tablename FROM pg_tables WHERE schemaname = 'public')
    LOOP
        EXECUTE 'DROP TABLE IF EXISTS "' || table_name ||'" CASCADE';
    END LOOP;
END
$$
;

-- 清空表, 并重置自增序列
TRUNCATE TABLE audit_logs CASCADE;
ALTER SEQUENCE audit_logs_id_seq RESTART;


-- 重置序列
DO
$$
DECLARE
    seq_name text;
BEGIN
    FOR seq_name IN (SELECT sequence_name FROM information_schema.sequences WHERE sequence_schema='public')
    LOOP
        EXECUTE 'ALTER SEQUENCE ' || seq_name || ' RESTART';
    END LOOP;
END
$$
;

视图

1
2

-- 查看视图的 创建语句
SELECT pg_get_viewdef('public.my_view'::regclass);

执行计划

1
2

explain sql_line;               -- 执行计划, 但实际没有执行
explain analyze sql_line;       -- 执行计划, 实际有执行

查询sql


-- 按 指定时区进行查询
SELECT COUNT(1) FROM kyc WHERE created_at < ('2024-08-20'::date AT TIME ZONE 'Asia/Shanghai');

-- 查询序列
SELECT nextval('addresses_address_id_seq');

运行巡检

-- 查看数据库大小
SELECT pg_size_pretty(pg_database_size('db1'));


-- 查询所有数据文件对象的大小
SELECT object_type, object_name, schema_name, size FROM
(SELECT
    'Table' AS object_type,
    relname AS object_name,
    schemaname AS schema_name,
    pg_total_relation_size(relid) as size_bytes,
    pg_size_pretty(pg_total_relation_size(relid)) AS size
FROM
    pg_catalog.pg_statio_user_tables
UNION
SELECT
    'Index' AS object_type,
    indexrelname AS object_name,
    schemaname AS schema_name,
    pg_total_relation_size(indexrelid) as size_bytes,
    pg_size_pretty(pg_total_relation_size(indexrelid)) AS size
FROM
    pg_catalog.pg_stat_all_indexes
) as data
ORDER BY
    size_bytes DESC;


--- 只查看表大小
SELECT
    'Table' AS object_type,
    relname AS object_name,
    schemaname AS schema_name,
    pg_total_relation_size(relid) as size_bytes,
    pg_size_pretty(pg_total_relation_size(relid)) AS size
FROM
    pg_catalog.pg_statio_user_tables
ORDER BY
    size_bytes DESC;