自己随便整理了一些数据库git之类的一些小知识，持续更新中
原文件是记录在txt中，可能有些不大好看
which python #liunx
数据库系统
OLTP
主要是业务操作数据库，工作简单只需要简单的事务能力就行，用户数量为上千个，库的大小也只有100MB-GB,但是时间要求很高，具有实时性
OLAP
主要是用于分析决策的数据仓库，要求有复杂的查询能力，用户数量可以是上百万个
数据语言：
DML(Data Manipulation Language)语句
DML使用范围：
是指对数据库中 表 记录的操作，主要包括表记录的插入(insert)、更新(update）、删除(delete)和查询(select)，是开发人员日常使用最频繁的操作。
DDL(Data Definition Language)数据定义语言：
DDL适用范围：
对数据库中的某些对象(例，database,table)进行管理，如Create,Alter和Drop
DQL 数据库查询语句：
DQL使用范围：
对数据库进行查询的操作，基本结构是select子句， from子句，where子句组成的查询块
DCL 数据控制语言：
DCL使用范围：
用来授予或者回收访问数据库的某种特权，并控制数据库操纵事务发生的事件及效果，对数据库实行监视等。如：
GRANT 授权
ROLLBACK [WORK] TO [SAVEPOINT] 回退到某一点
COMMIT [WORK] 提交
数据库提交的三种类型：
显式提交
COMMIT
隐式提交
用SQL命令间接完成的提交
ALTER,AUDIT,COMMENT,CONNECT,CREATE,DISCONNECT,
DROP,EXIT,GRANT,NOAUDIT,QUIT,REVOKE,RENAME
自动提交
可以设置AUTOCOMMIT ON
其他 二进制用法
1<<i 是将1左移i位，即第i位为1，其余位为0；
n&(1<<i)是将左移i位的1与n进行按位与，即为保留n的第i位，其余位置零
mysql
一些注意点：
定义变量只能在存储过程中才可以使用！！！ 也就是只能在begin...end中才可以使用，也成为存储过程变量。声明变量是，先是变量，再是类型：
例如：
declare var_1,address varchar;
declare var_3 varchar;
declare var_2 int default 0;
set var_1 = 'jay',var_2 = 3;
也可以直接在外面赋值：set @var=1; 作用域是整个会话，也称为用户变量
基本操作
IF NOT EXISTS
如果没有就创建这张表
存储过程
错误捕获
函数：
round()
如果传入一个参数，就把传入的参数四舍五入，保留至整数 例如：round(1.4) return 1
如果传入两个参数，第一个参数是你要处理的参数，第二个参数是保留第几位数 例如：round(91.335,-1) return 90
rand()
随机数，0<rand()<1
查询缓存：
查询缓存可以看作是sql文本和查询结果的映射。适合有大量相同查询的应用，不适合有大量数据更新的应用。
可以通过这条命令来查看缓存相关参数：
SHOW VARIABLES LIKE '%query_cache%';
其中有个字段 query_cache_type ,这个字段有0，1，2这三个类型，0是不使用查询缓存，1是始终使用查询缓存，2是按需使用查询缓存
如果是1但又不想使用缓存，就使用：SELECT SQL_NO_CACHE * FROM my_table WHERE condition;
如果是2，但要使用缓存，就要使用sql_cache开关参数：SELECT SQL_CACHE * FROM my_table WHERE condition;
至于还有query_cache_size这个字段，默认状态下是0，表示查询缓存预留的内存为0，也就无法使用查询缓存。于是我们需要设置query_cache_size的值：
SET GLOBAL query_cache_size = 134217728;
注意这个size值不能太小，如你要是设置为4000，那么你可以用： show warnings 来查看到下面的结果：
level code message
warning 1292 truncated incorrect query_cache_size value '4000'
warning 1282 query cache failed to set size 3072,new query cache size is 0
缓存条件：
如果第二次查询的sql和第一次查询的sql完全相同(一个标点都没错的那种)，且开启了查询缓存，那么第二次查询就直接从查询缓存中取结果
可以通过这个命令查看缓存命中的次数（是一个累加值）：
SHOW STATUS LIKE 'Qcache_hits';
而且即使是完全相同的sql，如果使用不用的字符集、不同的协议等也会被认为是不同的查询而分别进行缓存。
缓存数据失效时机：
当表的结构或者数据发生改变时，查询缓存中的数据不再有效。比如insert、update、delete、truncate、alter table、drop table或者drop database
会导致缓存数据失效。所以查询缓存适合有大量相同查询的应用，不适合有大量数据更新的应用。
清理缓存：
1、FLUSH QUERY CACHE; // 清理查询缓存内存碎片。
2、RESET QUERY CACHE; // 从查询缓存中移出所有查询。
3、FLUSH TABLES; //关闭所有打开的表，同时该操作将会清空查询缓存中的内容。
索引： 链接：https://www.2cto.com/database/201805/743736.html
alter table 'table_name' add index 'index_name' (column list);
通过‘show index from table_name’来查看该表的索引信息
基本信息
Table: sc_users #表名
Non_unique: 0 #该索引能不能包括重复值，可以则为1，不能为0
Key_name: phone #索引的名称
Seq_in_index: 1 #索引中的序列号，从1开始
Column_name: phone #列名称
Collation: A #有值‘A’(升序) 或者NULL (无分类)
Cardinality: 3 #索引中唯一值数目的估计值，通过运行ANALYZE TABLE或者myisamchk-a
Sub_part: NULL #如果是部分列被编入索引，值就是被编入索引的字符的数目；如果整列被编入索引，就为NULL值
Packed: NULL #指关键字如何被压缩，如果没有被压缩就是NULL
Null: #如果含有NULL值，就是YES；如果没有NULL值，就为NO
Index_type: BTREE #用过的索引方法（BTREE、FULLTEXT、HASH、RTREE）
Comment: #Index_comment评注
分区：
show variables like "%part%";
使用这个来查看数据库是否支持分区
修复：链接： https://www.iteye.com/blog/dinglin-1791922
analyze table (table_name)
用于修复索引的预估索引值 （如果设置了binlog，会把值保存到binlog中）(也可以通过analyze local table 来取消保存到binlog)
(大部分索引不生效可能就是这个原因，可以通过查看索引中的Cardinality字段来查看估计值)
checksum table (table_name)
数据校验值，可以校验数据是否一致
optimize table (table_name) 对MYISALM和InnoDB类型的表都有效
整理数据库碎片，保证数据库效率，建议定时运行该字段
(和analyze table一样，默认会把值保存到binlog中，可以在optimize 和 table中添加一个local来取消保存)
check table (table_name) 链接：http://www.360doc.com/content/13/0617/14/9437165_293479800.shtml
数据库经常可能遇到错误，譬如数据写入磁盘时发生错误，或是索引没有同步更新，或是数据库未关闭MySQL就停止了。
遇到这些情况，数据就可能发生错误：
Incorrect key file for table: ' '. Try to repair it.
此时，我们可以使用Check Table语句来检查表及其对应的索引。
check table sc_users;
返回：
+---------------------+-------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+---------------------+-------+----------+----------+
| flask_test.sc_users | check | status | OK |
+---------------------+-------+----------+----------+
像我这个是代表正确的
当他检查出错误之后，会把表标记为“corrupted”，并不能使用，直到修复为止，
当你的表被标记为“corrupted”之后，check table是不会找出表中的问题，在种情况下，他会把表标记为 良好
每当你运行之后，mysql会保存最近一次检查时间，每次运行check table都会存储这些信息：
执行
SELECT TABLE_NAME, CHECK_TIME
FROM INFORMATION_SCHEMA.TABLES
WHERE TABLE_NAME = 'PLAYERS' /*PLAYERS是表名*/
AND TABLE_SCHEMA = 'TENNIS'; /*TENNIS是数据库名*/
结果是
TABLE_NAME CHECK_TIME
* ---------- -------------------
PLAYERS NULL （我也不知道为什么，示例中是有值的 2006-08-21 16:44:25）
Check Table还可以指定其它选项： 例如：check table quick;
UPGRADE：用来测试在更早版本的MySQL中建立的表是否与当前版本兼容。
QUICK：速度最快的选项，在检查各列的数据时，不会检查链接（link）的正确与否，如果没有遇到什么问题，可以使用这个选项。
FAST：只检查表是否正常关闭，如果在系统掉电之后没有遇到严重问题，可以使用这个选项。
CHANGED：只检查上次检查时间之后更新的数据。
MEDIUM：默认的选项，会检查索引文件和数据文件之间的链接正确性。
EXTENDED：最慢的选项，会进行全面的检查。
repair table
用于修复表，只对MYISAM和ARCHIVE类型的表有效。
这条语句同样也可以指定选项：
QUICK：最快的选项，只修复索引树。
EXTENDED：最慢的选项，需要逐行重建索引。
USE_FRM：只有当MYI文件丢失时才使用这个选项，全面重建整个索引。
与analyze table一样，也可以通过 repair local table 来取消写入binlog
记录日志：
binlog: 链接：https://www.cnblogs.com/dadonggg/p/8617826.html
主要的作用时用于数据库的主从复制即数据的增量恢复
是一个二进制格式的文件，用于记录用户对数据库更新的sql语句信息，例如更改数据库表和更改内容的sql语句都会记录到binlog中，但是查询不会记录；
默认情况下binlog日志是一个二进制格式的，不能使用查看文本工具的命令（比如，cat，vi等）查看，而使用mysqlbinlog解析查看
当数据写入到数据库时，还会同时把更新的sql语句写入到对应的binlog文件中。使用mysqldump备份时，只是对一段时间的数据进行全备，
但是如果备份后突然发现数据库服务器故障，这个时候就可以用到binlog的日志了
数据库分区： 链接：http://blog.51yip.com/mysql/1013.html
pass（要看postgresql，暂时没时间看mysql，有时间再补）
优点：
1，分区可以分在多个磁盘，存储更大一点
2，根据查找条件，也就是where后面的条件，查找只查找相应的分区不用全部查找了
3，进行大数据搜索时可以进行并行处理。
4，跨多个磁盘来分散数据查询，来获得更大的查询吞吐量
sql注入必会的知识：
https://www.cnblogs.com/KevinGeorge/p/8446874.html
postgresql 链接：https://www.ximalaya.com/keji/17008073/148467863 是postgresql简介目录
whoosh_index这个方法来初始化全文索引，为了保持数据库和全文检索引擎的同步，在数据库中删除所有已经存在的数据，然后重新开始。
切记：除了json字段中必须要用 " " 双引号之外，一般最好都要用 ' ' 单引号！！
一些注意点：
where里头的条件列只能使用表别名.<真实列>
缺省 就是 默认的意思，例：缺省位置 --> 默认位置
进入：
windows：
windows可以设置环境变量：
PGHOST = localhost
PGPORT = 5432
PGUSER = postgres
之后就可以直接通过命令行：
psql
进入postgresql了
linux：
先连接上用户postgres
su - postgres
psql -U postgres
进入postgresql
如果时要远程连接还需要配置：
vi /var/lib/pgsql/12/data/postgresql.conf
在59行取消注释，更改为 listen_addresses = '*'
在395行，添加： log_line_prefix = '%t %u %d'
导入一个数据库数据：
psql -U username databasename < C:\Users\wuhaogongsi\Desktop\test_git/data.sql
用户名 数据库名
查看基础信息：（数据太多查询结果出现 -- More -- 时，按q、g是退出，p、s是行数，空格时快速查看28行数据）
select typname,typlen from pg_type where typname ~ '^timestamp';
查看 pg_type表中typname列中以 'timestamp'开头的所有结果
pg_type表是用来查看所有数据类型的属性，typlen列是该数据类型的占用大小
show time zone;
查看库的时区位置
select now();
查看库的当前时间，
select now() at time zone 'Asia/Shanghai';
查看 '上海' 时区的当前时间
set time zone 'PRC';
修改库的时区为 'PRC'
select * from pg_timezone_names;
pg_timezone_names表中包含了所有可用的时区
\echo :AUTOCOMMIT
查看是否开启自动提交功能，也就是说是否开启在执行插入、修改、删除语句执行后，是否自动提交
切记，一定要大写
create_time.strftime()
psql时间转换
数据类型：
smallint 2 字节 小范围整数 -32768 到 +32767
integer 4字节 常用整数 正负21亿 即 -2147483648 到 2147483647
bigint 8字节 大范围整数 -9223372036854775808 到 9223372036954775807
numeric 变量 用户指定的精度,精确 小数点前最多为131072个数字; 小数点后最多为16383个数字。 (一般用于取小数点后几位，也可以设置-n,例如-1表示保留十位)，一般用法： insert into test select 2,round(100*random()::numeric,-1) from generate_series(1,1);
real 4 字节 可变精度，不精确 6 位十进制数字精度
double precision 8 字节 可变精度，不精确 15 位十进制数字精度
smallserial 2 字节 自增的小范围整数 1 到 32767
serial 4 字节 自增整数 1 到 2147483647
*注意如果直接设置serial8 , 也就相当于是 bigserial
bigserial 8 字节 自增的大范围整数 1 到 9223372036854775807
money 8字节 货币金额 -92233720368547758.08 到 +92233720368547758.07
character 变长，有长度限制
varying(n) 变长，有长度限制
varchar(n) 变长，有长度限制
character(n) f定长，不足补空白
char(n) f定长，不足补空白
text 变长，无长度限制
timestamp 日期和时间，不带时区的时间戳 例如：2016-06-22 19:10:25
timestamptz 日期和时间，带时区的时间戳 例如：2016-06-22 22:10:25-04
date 只用于日期 例如：2016-06-22 若输入 2016-06-22 19:10:25-07，虽然也可以保存，但是只保存2016-06-22
time 只用于一日内时间 例如：19:10:25
timetz 只用于一日内时间，带时区 例如：19:10:25-07
interval 时间间隔 正负178000000年 例如：'1y 2mon 3d 100' 或者 '1 year 2 months 3 days 4 hours 5 minutes 6 seconds'
boolean 布尔类型 例如：'true' 或者 'false' 或者 null
枚举类型
create type mood as enum ('sad','ok','happy');
自定义的枚举类型，比如上面这个设置后，可以创建的字段类型直接写 mood ，设置后该字段只能是 'sad'，'ok'，'happy'
几何类型 (常用于地理位置)
point 16字节 平面中的点(其他类型的基础) （x,y)
line 32 字节 (无穷)直线(未完全实现) ((x1,y1),(x2,y2))
lseg 32 字节 (有限)线段 ((x1,y1),(x2,y2))
box 32 字节 矩形 ((x1,y1),(x2,y2))
path 16+16n 字节 闭合路径(与多边形类似) ((x1,y1),...)
path 16+16n 字节 开放路径 [(x1,y1),...]
polygon 40+16n 字节 多边形(与闭合路径相似) ((x1,y1),...)
circle 24 字节 圆 <(x,y),r> (圆心和半径)
网络地址类型(用这些数据类型存储网络地址比用纯文本类型好， 因为这些类型提供输入错误检查和特殊的操作和功能。)
（在对 inet 或 cidr 数据类型进行排序的时候， IPv4 地址总是排在 IPv6 地址前面，包括那些封装或者是映射在 IPv6 地址里的 IPv4 地址， 比如 ::10.2.3.4 或 ::ffff:10.4.3.2。）
cidr 7 或 19 字节 IPv4 或 IPv6 网络
inet 7 或 19 字节 IPv4 或 IPv6 主机和网络
macaddr 6 字节 MAC 地址
位串类型 (位掩码-->https://www.jianshu.com/p/4e73512c03b8)
位串就是一串 1 和 0 的字符串。它们可以用于存储和直观化位掩码。 我们有两种 SQL 位类型：bit(n) 和bit varying(n)， 这里的n是一个正整数。
bit 类型的数据必须准确匹配长度 n， 试图存储短些或者长一些的数据都是错误的。bit varying 类型数据是最长 n 的变长类型；更长的串会被拒绝。
写一个没有长度的bit 等效于 bit(1)， 没有长度的 bit varying 意思是没有长度限制。
全文检索，即通过自然语言文档的集合来找到那些匹配一个查询的检索
tsvector tsvector 的值是一个无重复值的 lexemes 排序列表， 即一些同一个词的不同变种的标准化。
tsquery tsquery 存储用于检索的词汇，并且使用布尔操作符 &(and)，|(or) 和 !(not) 来组合他们，括号用来强调操作符的分组。
UUID类型
uuid 例子：a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11
json类型 参考：https://www.cnblogs.com/zhangfx01/p/9506219.html
json 适合存储，存储快，但是查询慢
jsonb 适合检索，存储慢，但是查询快，还支持许多额外的操作符
对比：
不能搞错这个返回的类型，例如：
我先定义了'data'字段为json类型
notes=# insert into aa(data) select(select '[1,2,3]'::jsonb ->>2);
错误: 字段 "data" 的类型为 json, 但表达式的类型为 text
至于这第二个‘select‘ 可加可不加
notes=# insert into aa(data) select('[1,2,3]'::jsonb ->2);
INSERT 0 1
json和jsonb共同使用的操作符
操作符 *返回类型 数组[1,2,3] as data {"a":1,"b":2,"c":3} as data {"a":{"b":{"c":1}},{"d":[4,5,6]} as data
-> json select 'data'::jsonb->2 ==3 select 'data'::jsonb->'a' ==1 select 'data'::jsonb ->'a' == {"b":{"c":1}}
->> text select 'data'::jsonb->>2 ==3 select 'data'::jsonb->>'a' ==1 select 'data'::jsonb ->>'a' == {"b":{"c":1}}
#> json select 'data'::jsonb #> '{a,b}' ={"c": 1}
#>> text select 'data'::jsonb #>> '{a,b}' ={"c": 1}
注意：
拿 #> 查询，必须要用 '{}' 这个维度信息包起来
jsonb额外操作符
操作符 *返回类型 描述 例子 返回值
@> t(True)/f(False) 左边的json值中是否包含右边json select '{"a":1,"b":{"c":2,"d":3}}'::jsonb @> '{"b":{"c":2}}'::jsonb; t
<@ t(True)/f(False) 和@>相反 pass
？ t(True)/f(False) 判断右边的值是否是左边的键之一 select '{"a":1,"b":2}'::jsonb ? 'b'; t
?| t(True)/f(False) 判断右边array[]中任何一个是否是左边的键 select '{"a":1,"b":2}'::jsonb ?| array['c','b']; t
?& t(True)/f(False) 判断右边array[]中是否都是左边的键 select '{"a":1,"b":2}'::jsonb ?& array['b','a']; t
|| jsonb 把左边和右边的jsonb联系起来,如果右边是已有的数据，就会覆盖 select '{"a":1,"b":2}'::jsonb || '{"b":3,"c":4}'::jsonb,
'{"a":1,"b":2}'::jsonb || '{"b":3,"c":4}'::jsonb; [{"a": 1, "b": 2}, "b", "c"],{"a": 1, "b": 3, "c": 4}
- jsonb 如果右边是字符串类型，左边就删除右边的键 select '{"a":1,"b":2}'::jsonb - 'c'; (不存在不报错) {"a": 1, "b": 2}
- jsonb (同上删除操作) 如果右边是int类型,左边就删除右边的下标,右边要不是列表就报错 select '[1,2,3,4]'::jsonb - 1; [1, 3，4]
#- jsonb 右边是字符串 套 一个字典，根据右边内容删除左边键值 select '{"a":{"b":1,"c":{"d":1}}}'::jsonb #- '{a,b}'; {"a": {"c": {"d": 1}}}
select '["a",{"b":1,"c":{"d":1}}]'::jsonb #- '{1,c,d}'; ["a", {"b": 1, "c": {}}]
XML类型
可以用于存储XML数据
（使用该类型，在编译时必须使用 configure --with-libxml）
创建XML值：
可以使用xmlparse() 来从字符串中产生xml类型的值，例如：
XMLPARSE (DOCUMENT '<?xml version="1.0"?><book><title>Manual</title><chapter>...</chapter></book>')
XMLPARSE (CONTENT 'abc<foo>bar</foo><bar>foo</bar>')
数组类型：
PostgreSQL 允许将字段定义成变长的多维数组。
数组类型可以是任何基本类型或用户定义类型，枚举类型或复合类型。
插入时使用大括号 {}，元素在{}使用逗号隔开，例如：
INSERT INTO sal_emp
VALUES ('Bill',
'{10000, 10000, 10000, 10000}',
'{{"meeting", "lunch"}, {"training", "presentation"}}');
数组操作：
操作符 描述 示例 结果
= 相等 SELECT ARRAY[1.1,2.1,3.1]::int[] = ARRAY[1,2,3]; t
<> 不等于 select ARRAY[1,2,3] <> ARRAY[1,2,4]; t
< 小于 select ARRAY[1,2,3] < ARRAY[1,2,4]; t
> 大于 select ARRAY[1,4,3] > ARRAY[1,2,4]; t
<= 小于等于 select ARRAY[1,2,3] <= ARRAY[1,2,4]; t
>= 大于等于 select ARRAY[1,4,3] >= ARRAY[1,2,4]; t
@> 包含(完全包含) select ARRAY[1,2,3] @> ARRAY[1,2]; t
<@ 包含于 pass (同上，不过左右反过来写)
&& 重叠(是否有相同元素) select ARRAY[1,4,3] && ARRAY[2,1]; t
|| 数组与数组 select ARRAY[1,2,3] || ARRAY[4,5,6]; {1,2,3,4,5,6}
|| 一维与二维数组 select ARRAY[1,2,3] || ARRAY[[4,5,6],[7,8,9]]; {{1,2,3},{4,5,6},{7,8,9}}
|| 元素与数组连接 select 3 || ARRAY[4,5,6]; {3,4,5,6}
|| 数组与元素连接 select ARRAY[4,5,6] || 7; {4,5,6,7}
操作：https://www.runoob.com/postgresql/postgresql-syntax.html 杂七杂八的都在这个网址里面
\l
展示所有库
\c 数据库名
进入该数据库
\c - 用户名
切换成该用户
\di
列出所有索引
\d+
列出所有表的归属大小信息
\dt+
列出所有主表的归属大小信息
\d
列出所有表
\d tablename
列出该表的结构
\dx
查看已安装的扩展
测试：
explain
在执行操作之前加上explain之后，可以查看执行这条操作之后的执行计划，但并不执行
explain analyze
在执行操作之前加上explain analyze之后，可以查看执行这条操作之后的执行计划，且执行该操作
*如果是DML操作（drop、select、create、insert into)，需要在执行前开启事务，然后查看执行，最后回滚
例如：
postgres=# begin;
postgres=# explain analyze xxxxxxxxx;
postgres=# rollback;
例如
EXPLAIN ANALYZE SELECT *
FROM tenk1 t1, tenk2 t2
WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2 ORDER BY t1.fivethous;
第一条数据：
Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=101 width=0) (actual time=0.049..0.049 rows=100 loops=1)
Index Cond: (unique1 < 100)
cost表示的是预测时间，actual time是实际时间，loops是循环的次数
planning time:计划时间，Execution time:执行时间
操作符：
:: 转换类型，例如： '1'::int 转换成int类型
|| 连接符，例如 : select 7||'m'; 结果就是 7m
函数：
trunc()
用于取整
random()
用于产生随机数，0<random()<1
uuid_generate_v4()
用于产生随机uuid,但是返回出来的值是有 "-" 的,例如：49d8ae43-8014-415b-ae8e-81e063db30bb，所以推荐搭配replace(uuid_generate_v4()::varchar,'-','')使用，出来的结果是32位字符串，例如：93dd39775e014b7b8734a2c25d7adaaa
（postgresql没有uuid_generate_v4这个函数，使用前需要执行：create extension "uuid-ossp"，不过这个只是作用与当前数据库，可以参考链接：https://blog.csdn.net/duanbiren123/article/details/81274724）
上面是创建类型为varchar(32)的前提下，你也可以直接设置为字段类型为uuid，就可以直接传入uuid_generate_v4()数据
generate_series(num1，num2)
该函数可以遍历执行从num1到num2的数，例如：
insert into table_name
select r ,r||'_tans' from generate_series(1,2000000)r
导入了200万条数据，例如其中的一个数据是：
id name
1 1_tans
2 2_tans
xmlparse()
用于从字符串中提取XML值，例如：
XMLPARSE (DOCUMENT '<?xml version="1.0"?><book><title>Manual</title><chapter>...</chapter></book>')
XMLPARSE (CONTENT 'abc<foo>bar</foo><bar>foo</bar>')
array_agg()
用于当你查询数据不只是一条是，会把你查询出来的数据都放进一个数组里面返回给你，不过如果是数组类型，就必须要是相同维度的数组才行
例如：
select array_agg(phone) from sal_emp;
返回值为：
{{1000,1000},{1000,1000},{1000,1000}}
regexp_match() 从第一位开始匹配
用于正则匹配，例如：
select regexp_match('123-123','(\d+)-(\d+)')
返回出来的结果是：
{123,123} #注意如果要查询出来这里第一条数据，就要使用嵌套查询select (select regexp_match('123-123','(\d+)-(\d+)'))[1];
第二个select可以不写，例如：select (regexp_match('123-123','(\d+)-(\d+)'))[1];
pgstattuple() 统计表或者索引的详细空间占用情况
首先 create extension pgstattuple
select * from pgstattuple( '表名或者索引名' )
其中的字段解释：
字段 类型 描述
table_len bigint 物理关系长度，以字节计
tuple_count bigint 活的元组的数量
tuple_len bigint 活的元组的总长度，以字节计
tuple_percent float8 活的元组的百分比
dead_tuple_count bigint 死的元组的数量
dead_tuple_len bigint 死的元组的总长度，以字节计
dead_tuple_percent float8 死的元组的百分比
free_space bigint 空闲空间总量，以字节计
free_percent float8 空闲空间的百分比
**注意，表长度(table_len)总是大于 活的元组的总长度(tuple_len),死元组的总长度(dead_tuple_len)和空闲空间总量(free_space)的总和，这是由
固定的页面开销、指向元组的每页指针表和确保元组正确对齐的填充来解释的。
pg_relation_size() 用来统计表的大小，不过传入的参数可以是 oid 也可以是 表名
例如：
select pg_relation_size(16615)
结果是：
pg_relation_size
------------------
0
to_tsvector( ) 用来
数组方法函数:
array_append(array,元素)
把元素添加进数组中，例如：
SELECT array_append(ARRAY[1,2], 3);
结果： {1,2,3}
查看所有的存储过程：
select * from pg_proc;
查看指定的存储过程：
select proname,prosrc from pg_proc where proname = 'function_name';
保留一位小数：
select round(random()::numeric,1);
这里的random()就相当于你传入要保留一位小数的值
修改一组数据：
update 表名 set 字段=修改后的字段 where 指定修改的列
例如：
update test_jsonb set j_jsonb = j_jsonb || {"a":1}::jsonb where j_jsonb@>'{"b":2}'::jsonb
给j_jsonb字段添加{"a":1}
仅删除该表所有数据：
truncate table tablename
给表重命名：
alter table 原表名 rename to 修改的表名；
删除字段：
alter table 表名 drop column 字段名；
修改表中的某行某列的数据：
update 表名 set 目标字段名=目标值 where 该行特征；
模糊查询：
一般：
select * from 表名 where 字段 like ('%' || '关键字' || '%')；
或者：
select * from 表名 where 字段 ~* '关键字'；
最佳：(据说可以在关键字内输入任何特殊符号，都可以正常查询 ！！)
SELECT * FROM 表名 WHERE 字段 ILIKE regexp_replace(concat('%','关键字','%'),'\\','\\\','g')
取多条参数：
select * from 表名 limit param1; param1代表你要传的条数
select * from 表名 limit param1 offset param2; 从 (param2+1) 条数据开始，取param1条参数
生成随机汉字：
现附上链接： https://blog.csdn.net/weixin_34260991/article/details/90585081
查看统计表占用空间：
一、查找pg_class
select relpages as 占用空间,reltuples 记录数 from pg_class where relname=表名;
二、使用psql命令
\dt+ 表名
三、使用pgstattuple扩展
select * from pgstattuple(表名);
缓存： 链接：https://my.oschina.net/swuly302/blog/146529#OSC_h3_1 以及 https://www.cnblogs.com/linguoguo/p/10896235.html 再或者简洁一些的：https://blog.csdn.net/liufeng1980423/article/details/102780810
可以通过以下步骤查询postgresql数据缓存情况
1、创建pg_buffercache
物理储存：链接： http://rachbelaid.com/introduction-to-postgres-physical-storage/
数据库集群使用的数据文件存储在集群的数据目录中，该目录通常称为PGDATA(在可用于定义它的环境变量的名称之后)。PGDATA在您的操作系统或者安装中可能具有不同的位置
简单得说，对于集群得每一个数据库，都是对应一个 PGDATA/base 的子目录，子目录的名字就是该数据库在 pg_database 的oid。这个子目录是该数据库文件的缺省位置（也就是默认位置）；
特别值得一提的是，该数据库的系统表存储在此。每个表和索引都存储在独立的文件里，以该表或者该索引的 filenode 号命名，该号码可以在pg_class . relfilenode中找到
注意，虽然一个表的 filenode 通常和它的oid相同，但是实际上并不一定是这样；有些操作比如 truncate，reindex，cluster以及一些特殊的alter table形式，
都可以改变 filenode 而同时保留oid不变，所以不能断言 filenode 和表oid就一定相同。
数据库储存：
对于集群中的每一个数据库，其中都有一个子目录 PGDATA/base ,命令行的话是在pg_database中,每个数据库都有对应的oid。此目录是数据库文件的默认位置。
库的oid查询：
如果要列出集群中每个数据库的oid，可以运行以下的查询：（如果要找对应的数据库，可以使用where datname= 'XXX'）
select oid,datname from pg_database;
结果是：
oid | datname
-------+-----------
13012 | postgres
1 | template1
13011 | template0
16395 | test_pg
16445 | notes
(5 行记录)
也可以在cmd中执行：
oid2name
结果是：
All databases:
Oid Database Name Tablespace
----------------------------------
16445 notes pg_default
13012 postgres pg_default
13011 template0 pg_default
1 template1 pg_default
16395 test_pg pg_default
表储存：
每个表都存储在一个单独的文件中。对于普通关系，这些文件以表或索引的文件节点号命名，可以
relfilenode在表的列中找到pg_class。pg_class是存在于pg_catalog架构中的系统表
当表超过1GB是，它将被分成千兆字节大小的段，第一段的文件名和filenode相同，随后的段分别命名为filenode.1,filenode.2等。这种安排可以避免在文件大小受限制的平台上出现问题。
表的oid查询：
你可以直接通过数据库来查询到他的存储的整个路径：
select pg_relation_filepath('表名');
结果是：
pg_relation_filepath
----------------------
base/16445/16486
(1 行记录)
如果你只是想获取表的oid，可以直接在cmd中操作：
oid2name -d 库名 -t 表名
结果是：
From database "notes":
Filenode Table Name
----------------------
16486 aa
系统表：
当你创建数据库时，除了public(公众的)和用户创建的模式外，每个数据库还包含一个 pg_catalog 模式，该模式包含系统表以及所有内置数据类型、函数和运算符。
pg_catalog(catalog : 目录) 总是有效的成为搜索路径的一部分，因此在查询系统表时不需要使用前缀。
列出所有系统表的列表：
\dt pg_catalog.*
结果一部分是：
架构模式 | 名称 | 类型 | 拥有者
------------+--------------- ---+--------+----------
pg_catalog | pg_aggregate | 数据表 | postgres
pg_catalog | pg_am | 数据表 | postgres
pg_catalog | pg_amop | 数据表 | postgres
-- More --
pg_stat_activity : 链接： https://blog.csdn.net/luojinbai/article/details/44586917
该表时一个系统视图，每一行都表示一个系统进程，显示与当前会话的活动进程的一些信息，比如当前会话的状态和查询等
该表的所有字段可以去链接中查看，说说重要的字段
state :
该字段有六个状态：
active 活动的，后端执行查询
idle 空闲的，后端正在等待新的客户端命令
idle in transaction 事务中空闲，后端处于事务中，但当前未执行查询
id in transaction (aborted) 事务中空闲(终止)，与事务中的空闲类似，但事务中的某个语句(声明)导致错误
fastpath function call fast path函数调用，后端正在执行一个fastpath函数
disabled 禁用，如果在此后端禁用了跟踪活动，则会报告此状态( This state is reported iftrack_activities is disabled in this backend )
行的存储方式：
每个表都存储为固定大小(通常为8kb)的页面数组。在一个表中，所有页面在逻辑上都是等效的，因此特定项目 (行) 可以存储在任何页面)
用于存储表的结构是一个堆文件。堆文件是可变大小的无序记录的列表。堆文件的结构为页面(或块)的集合，每一个页面包含项的集合。术语项是指存储在页面上的一行。
页面结构图：
http://rachbelaid.com/assets/posts/heap_file_page.png
它包含一些我们不打算介绍的标头，但是它们提供有关校验和，可用空间的开始，可用空间的结束等信息。镖头后的项目是由 (偏移，长度) 对组成的数组标识符，指向实际项目。
因为项目标识符知道被释放才被移动，所以即使项目本身在页面上四处移动以压缩可用空间，它的索引也可以长期用于引用项目。一个项目的指针称为CTID (ItemPointer)，由PostgreSQL创建，它由页码和项目标识符的索引组成。
项目本身存储在从未分配空间的末尾的空间中，粽子，一个页面里面的指针行被存储在开始 ， 元组(行)被存储在页的末尾。
你可以通过添加 ctid 选定的列来访问行的CTID:
select ctid,* from 表名；
结果是：
ctid | id | data
-------+----+-------------------
(0,1) | 1 | {"keys":"values"}
(0,2) | 2 | 3
(0,3) | 3 | 3
(3 行记录)
限制：
根据About PostgreSQL，最大列数在250到1600之间，具体取决于列类型。列类型会影响他，是因为在Postgresql中，行的宽度最多为8kb（一页），它们不能跨越页面。
但是这并不意味着列的值限制为8kb，根据类型的不同，列中可能有较大的值，因为postgresql具有成为TOAST的机制，可以处理该问题。可以容纳多少列，取决于所使用的数据类型的宽度。即使指向TOAST属性的指针仍然需要一些字节。
（我感觉 ，总的来说就是你设置列的时候，如果是定长的属性，那么列的大小就是那个属性，如果你设置的是不定长的属性，那么当你储存的数据大约是 2kb 之后，就会使用到postgresql的TOAST机制，即把数据分摊给TOAST表，来给你分配这个列的大小。）
超大属性存储技术： 链接：http://www.postgres.cn/docs/9.4/storage-toast.html ，https://my.oschina.net/Kenyon/blog/113026
TOAST
pg_class:
这个表记录这postgresql几乎所有字段或者那些类似表的东西。包括索引 (索引还有它对应的pg_index) ，序列，试图，符合类型和一些特殊关系类型；
里面的字段是：
（
relation ：相当于表的意思 ，
tuple 或者 item ：相当于行的意思，
filenode ：是一个ID，代表对表或索引的引用，
block 和 page 等于，它们表示存储表的文件的8kb段信息，
heap 参考 heap file 。堆文件是可变大小的无序记录的列表。尽管堆文件名相似，但堆文件与对数据结构不同，
CTID ：表示表中行版本的物理位置。CTID也是特殊的列，可用于每个表，但除非特别说明，否则不可见。它由页码和项目标识符的索引组成，
oid ：代表对象标识符，
database cluster ：我们称数据库集群为磁盘上的存储区域。数据库集群是由运行中的数据库服务器的单个实例管理的数据库的集合，
vaccum ：PostgreSQL数据库需要定期维护，即所谓的清理，
）
名称 类型 参考 描述
oid oid 行标识符（隐藏属性;必须明确选择）
relname name 表格，索引，视图等的名称
relnamespace oid pg_namespace.oid 包含此relation的名称空间的oid
reltype oid pg_type .oid 与此表行类型对应的数据类型的oid（如果有的话）（对于没有pg_type条目的索引，为零 ）
reloftype oid pg_type .oid 对于类型表，基础复合类型的oid，对于所有其他relation为零
relowner oid pg_authid.oid relation的所有者
relam oid pg_am.oid 如果这是一个索引，则使用的访问方法（B-树，散列等）
relfilenode oid 该relation的磁盘文件的名称; 零表示这是一个“映射”relation，其磁盘文件名由低级状态决定
reltablespace oid pg_tablespace.oid 存储该relation的表空间。如果为零，则隐含数据库的默认表空间。（如果relation没有磁盘上的文件，则无意义。）
relpages int4 该表的磁盘表示的大小（页面大小为BLCKSZ）。这只是计划者使用的估计值。
它由VACUUM，ANALYZE和一些DDL命令（如CREATE INDEX）更新。
reltuples float4 表中的行数。这只是计划者使用的估计值。
它由VACUUM，ANALYZE和一些DDL命令（如CREATE INDEX）更新。
relallvisible int4 在表格的可见性图中标记为全部可见的页面数。这只是计划者使用的估计值。
它由VACUUM，ANALYZE和一些DDL命令（如CREATE INDEX）更新。
reltoastrelid oid pg_class .oid 与此表关联的TOAST表的oid，如果没有，则为0。TOAST表在“辅助表”中存储“超出行”的大型属性 。
relhasindex bool 如果这是一个表并且它有（或最近有）任何索引，则为真
relisshared bool 如果此表在群集中的所有数据库之间共享，则为true。只有某些系统目录（如 pg_database）被共享。
relpersistence char p =永久表， u =未记录表，t =临时表
relkind char r =普通表， i =索引，S =序列，v =视图，m =物化视图， c =复合类型，t = TOAST表，f =外部表
relnatts int2 relation中的用户列数（系统列未计数）。pg_attribute中必须有许多相应的条目。另见pg_attribute.attnum。
relchecks int2 表上CHECK约束的数量; 请参阅pg_constraint目录
relhasoids bool 如果我们为relation的每一行生成oid，则为真
relhaspkey bool 如果表具有（或曾经有）主键，则为真
relhasrules bool 如果表具有（或曾经有）规则，则为真; 请参阅pg_rewrite目录
relhastriggers bool 如果表具有（或曾经有）触发器，则为真; 请参阅 pg_trigger目录
relhassubclass bool 如果表有（或曾经有过）任何继承孩子，则为真
relrowsecurity bool 如果表已启用行级安全性，则为true; 请参阅 pg_policy目录
relforcerowsecurity bool 如果行级别安全性（启用时）也为true，则也适用于表所有者; 请参阅pg_policy目录
relispopulated bool 如果relation被填充，则为真（对于除某些实例化视图之外的所有relation都是如此）
relreplident char 用于为行构成“副本标识”的列：d = default（主键，如果有的话），
n =无，f =所有列 i =具有indisreplident set的索引或default
relfrozenxid xid 在此表之前的所有交易ID已被替换为永久（“冻结”）交易ID。这用于跟踪是否需要将表抽真空以防止事务ID环绕
或允许缩小pg_clog。零（InvalidTransactionId）如果relation不是一个表。
relminmxid xid 在此表之前的所有多重作业ID已由该事务ID替换。这用于跟踪是否需要将表抽真空以防止多轴实现ID 绕回
或允许缩小pg_multixact。零（InvalidMultiXactId）如果relation不是一个表。
relacl aclitem[] 访问权限; 看到GRANT (给予权限) 和REVOKE (撤销权限) 的细节
reloptions text[] 特定于访问方法的选项，如“keyword = value”字符串
Sequence序列：
创建Sequence：
create sequence seq_name
increment 1 #增量步长为1
minvalue 1 #最小值为1
maxvalue 9223372036854775807 #最大值为9223372036854775807
start 1 #从1开始
cache 1 #缓存为1
cycle； #循环，表示到最大值后从头开始
删除Sequence：
drop sequence seq_name;
操作Sequence: 链接：https://www.cnblogs.com/mchina/archive/2013/04/10/3012493.html
Sequence是一种自动增加的数字序列，一般作为行或者表的唯一标识，用作代理主键。
一般是用在serial (自增字段类型) 中
create table tablename(
colname serial
);
等价于：
create Sequence tablename_colname_seq;
create table tablename(
colname integer default nextval('tablename_colname_seq') not null
);
你可以看每当我们一个表设置serial字段类型时，总是在这个表下面又创建了一个 表名_列名_seq 的表
为了提高postgresql的读能力，可使用Query Cache：
pass
终止活动连接/会话：
当想删除数据库时报错说还有会话存在时，就可以使用这个方法终止会话
总思想：
可以使用pg_terminate_backend()函数和pg_stat_activity视图来终止数据库上的活动连接
首先查看一下视图pg_stat_activity信息 (这个视图时自带的)
然后就有了下面的sql语句：
SELECT
pg_terminate_backend(pid)
FROM
pg_stat_activity
WHERE
pid <> pg_backend_pid() # 不终止当前连接
AND datname = 'target_database'; # 只终止target_database上的连接
查看用户连接总数：
select count(*) from pg_stat_activity;
查看所有连接的用户：
select * from pg_stat_activity;
取消当前某一个进程的查询操作，但不释放它的数据库连接：
select pg_cancel_backend( 填入通过pg_stat_activity中查询出来的用户pid )
后台杀死某一个进程，并取消它的数据库连接，即释放出宝贵的数据库连接资源：
select pg_terminate_backend( 填入通过pg_stat_activity中查询出来的用户pid )
杀死所有空闲的进程：
select pg_terminate_backend(pid) from pg_stat_activity where state='idle';
git：coding *使用 git bash ，不然有些命令用不了
(
#如果用coding就没必要设置括号中的内容
设置git全局配置用户名称：
git config --global user.name "用户名"
设置git全局配置用户密码：
git config --global user.email "邮箱"
查看全局配置用户名称：
git config --global user.name
查看全局配置用户密码：
git config --global user.email
)
#链接：https://blog.csdn.net/qq_36150631/article/details/81038485
先登录你的coding工作站，
配置公钥：
ssh-keygen -t rsa -C "[email protected]"
打开公钥：
C:\Users\wuhaogongsi\.ssh
中的id_rsa.pub文件，以记事本打开
添加公钥：
打开coding进行添加
操作：链接：https://blog.csdn.net/qq_36150631/article/details/81038485
pwd 显示当前全路径
git remote show
git init 初始化
git remote add origin git@github.com:YongHaoWu/test.git 初始化本地仓库 (coding不用设置) (origin 是你后面git@github.com... 的一个命名，也就相当于你对应的远程仓库的主机名)
git add . 把工作区的文件都添加到暂存区
git commit -m '注释' 把暂存区提交到本地仓库
git status 查看是否有文件的状态 (一般来查看是否有文件未提交)
git diff . 查看文件夹下所有文件与 暂存区 中的文件的差异
git diff HEAD 查看文件夹下所有文件与 本地仓库 中的文件的差异
git diff HEAD^ HEAD 查看最近一次commit与最近一次commit的上一次commit的差异
git diff HEAD -- ./lib 查看当前分支下，lib文件夹下的文件和上次提交之间的差别
git diff 版本号_1 版本号_2 查看两个版本号之间的差异
git log 查看修改仓库文件的日志；如果查询完之后跳出 END ，按 q 就可以了
git log --pretty=oneline 简单例举修改仓库文件的日志
git reset 取消add添加
git reset --hard HEAD^ 回退到上一个版本 (本地文件也修改)
git reflog 查看所有版本号
git reset --hard 版本号 恢复到指定的版本，工作区中的代码也回滚到那个指定版本
git reset --soft 版本号 恢复到指定的版本，工作区中的代码不变
git checkout -- . 丢弃工作区的修改 (如果已经提交到暂存区的就不会删除)
git checkout -b 名称 创建+切换分支 (如果分支已经存在，就不能加-b)
git checkout 名称 更换分支
git add . & git stash save '本次暂存标记的名字' 遇到临时有其他事情要做 但是又不想提交上去的时候，就可以使用stach暂存起来
git stash list 查看当前暂存的记录
git stash pop stach@{标记号码} 恢复暂存起来的数据，删除stach里的数据
git stash apply stach@{标记号码} 恢复暂存起来的数据
git branch -D 分支名称 删除本地分支
rm 文件名字加后缀 删除暂存区的指定文件，如果不小心被rm删除了，可以通过 git checkout -- 被删除的文件名 来恢复文件，前提是不要被commit提交了
git branch 查看本地仓库的所有分支
git branch -a 本地仓库与远程仓库对比所有分支的情况 (绿色的是本地仓库的分支，红色的是远程仓库的分支)
git branch -d 分支名称 删除本地仓库的指定分支
git fetch --all & git reset --hard origin/分支 两个连用的目的是用origin/master 覆盖本地分支，一般是本地分支和远程分支由冲突时重置用
git push -u 默认主机名称(origin) 把本地仓库提交到远程仓库 (第一次提交，后面再提交可允许不指定主机)
git push 把本地仓库提交到远程仓库
git push --force 覆盖远程分支
git push --all 把本地的所有分支都提交到远程仓库
git push 主机名称(origin) 分支名 提交指定的分支
git push 主机名称(origin) --delete 分支名 删除指定主机的远程分支 * (注意一定要加主机名称)
git pull 主机名称(origin) 远端分支名 把远端指定的分支名导入本地
git merge 分支名称 把某分支与当前分支合并起来
git gc & git count-objects -v & git checkout -f 把本地仓库的内容恢复到本地
git clean -d 清空所有新建的文件和文件夹
还有一些关于commit分割的问题：
如何用 rebase 、 reset 和 commit 来分割既有的提交。
以后用到了再整理
git配置：
git config core.sparsecheckout true 配置git允许pull指定的文件或文件夹
git config core.excludesfile ~/.idea 配置该仓库自动忽略.idea文件夹，
git config --global core.excludesfile ~/.idea 全局配置git自动
windows操作： 链接：https://www.cnblogs.com/yanqiong/p/10587960.html
dir 展示当前文件夹里的文件 例如：dir
mkdir 创建文件夹 例如：mkdir 'test_operate'
touch 创建文件 要加后缀 例如：touch operate.txt
cat 显示文件内容 例如：cat operate.txt
echo 添加内容至文件内 例如：echo 111111 >> operate.txt
cls 清空cmd
linux操作： https://blog.csdn.net/qq_27270029/article/details/80636198
mkdir 创建文件夹
mv 移动文件夹 例如 mv '文件名' /usr/conf/java
touch 创建文件 例如 touch '文件名.后缀'
tail 查看文件最后几行 例如 tail '文件名'
tail -f 实时查看文件内容 例如 tail -f '文件名'
virtualenv：
windows虚拟环境配置：链接：https://www.jianshu.com/p/a83a8f5d68dd?utm_campaign=maleskine&utm_content=note&utm_medium=writer_share&utm_source=weibo
下载：
python -m pip install virtualenv
创建新的虚拟环境：
virtualenv -p D:\my_environment\python.exe venv #D:\... 是你虚拟环境对应的python程序，venv是你的虚拟环境名称
进入虚拟环境：
cd 到对应虚拟环境中的Scripts中
打开cmd，执行activate 就可以了
退出：
执行 deactivate
(
经试验，deactivate不需要是对应虚拟环境，只需要是个deactivate.bat就行，
所以建议把这个脚本单独弄一个环境变量，就不用每次都cd 到对应的路径中了。
例如我是单独在系统目录中创建了一个deactivate文件夹，放入deactivate.bat，再配置对应的环境变量就可以了
)
sourcetree：
这是windows的git 可视化工具，主要是方便查看解决冲突
配置本地仓库：
先在页面上面找到 +create ,填写入本地路径就可以了
配置远程仓库:
1、首先参考上面git 的教程配置好公钥
2、打开页面，选择 '工具' > '选项'
3、配置好里面的默认用户信息和SSH客户端配置，SSH客户端选择 'OpenSSH' ，然后选择SSH密钥路径，也就是第一步你生成的密钥文件id_rsa.pub，确定。
4、选择 '工具' > '添加SSH密钥' ，选择你的密钥文件id_rsa.pub
5、选择 '设置' > 远程仓库 '添加' ，远程名称默认为origin，再填上你coding项目的 SSH 的路径 例如'[email protected]:........'
flask:
不使用外键：
https://graycarl.me/2016/12/27/sqlalchemy-without-foreignkey.html
flask_ngx:
https://zhuanlan.zhihu.com/p/38859762
获取flask_sql 获取数据库已有的表
https://blog.csdn.net/weixin_40238625/article/details/88177492
flask_orm基础
https://www.cnblogs.com/huchong/p/8274510.html
orm没有外键多表联查：
data = db.session.query(models.TbArticle, models.TbArticleContent)
data.join(models.TbArticle, models.TbArticle.uuid == models.TbArticleContent.uuid)
current_app 上下文： 链接：https://blog.csdn.net/m0_37323771/article/details/80645100 ， https://blog.csdn.net/JENREY/article/details/86606653
pass
请求钩子：
@app.before_first_request
再第一次请求之前调用，可以用作初始化
@app.before_request
在每一次请求之前调用，这很好已经有请求里，可能在这个里面做校验
@app.after_request
在执行完视图函数之后会调用，并会把视图函数所生成的响应传入，可以在此方法中对响应做最后一步统一的处理
例如：
@app.after_request
def after_request(response):
print("after_request")
response.headers["Content-Type"] = "application/json"
return response
@app.teardown_request
每一次请求之后都会调用，会接受一个参数，参数是服务器出现的错误信息，
例如：
@app.teardown_request
def teardown_request(e):
print("teardown_request")
flask_sqlalchemy:
重写filter_by:
例如可能某个项目中，status是逻辑删除的标志，每次查询都需要加上status=1，比如Gifts.query.filter_by(uid=current_user.id, status=1)
于是我们可以重写filter_by:
filter_by等查询函数定义在sqlalchemy.orm.Query中，flask_sqlalchemy.BaseQuery继承了orm的Query, 因此我们重写的时候是直接继承BaseQuery。
Orm.Query ——> BaseQuery ——> 自定义Query
自定义的filter_by的代码为：
class Query(BaseQuery):
def filter_by(self, **kwargs):
if 'status' not in kwargs.keys():
kwargs['status'] = 1
return super(Query, self).filter_by(**kwargs)
然后得指定query：
db = SQLALchemy( query_class = Query )
中文全文索引优化：
https://www.codercto.com/a/25848.html
https://www.cnblogs.com/zhenbianshu/p/8253131.html
pytest 链接：http://www.pytest.org/en/latest/
--setup-show 获取详细的测试用例运行流程
-x 出现异常立即结束测试
redis:
启动server：
redis 2.X 版本需要cd到redis目录下边，redis-server redis.windows.conf 也就是启动时添加它的conf配置
redis 3.X 版本就只需要redis-server
redis普通配置：
r = redis.Redis( host='127.0.0.1', port=6379, db=3 )
redis缓存池：
pool = redis.ConnectionPool( host='127.0.0.1', port=6379, db=3 )
r = redis.Redis( connection_pool=pool )
把redis缓存池中的所有缓存keys取出来：
list_id = r.keys()
判断执行结果：
from celery.result import AsyncReault
for i in list_id:
asy = AsyncResult( id=i.decode(), app=cel )
if asy.successful():
result = asy.get()
print(result)
# result.forget() # 将结果删除,执行完成，结果不会自动删除
# asy.revoke(terminate=True) # 无论现在是什么时候，都要终止
# asy.revoke(terminate=False) # 如果任务还没有开始执行呢，那么就可以终止。
elif asy.failed():
print('执行失败')
elif asy.status == 'PENDING':
print('任务等待中被执行')
elif asy.status == 'RETRY':
print('任务异常后正在重试')
elif asy.status == 'STARTED':
print('任务已经开始被执行')
哨兵配置：通过哨兵可以创建一个当主服务器出现故障时自动将从服务器升级为主服务器的一个分布式系统。解决了主从复制出现故障时需要人为干预的问题。
这篇介绍哨兵的搭建，以及哨兵是如何进行哨兵发现和主从切换等功能。 链接：https://yq.aliyun.com/articles/624355spm=a2c4e.11155472.0.0.6b027c62W6cXjQ
pass (没用过，可以看文档)
查看缓存信息： 链接：https://www.jianshu.com/p/b6f08341a3ec
redis：
查看消息长度 redis-cli -h 127.0.0.1 -p 6379 -n 1 llen celery
查看消息队列具体内容 redis-cli -h 127.0.0.1 -p 6379 -n 1 LRANGE key 0 -1
清空队列全部内容 redis-cli -h 127.0.0.1 -p 6379 -n 1 ltrim key 0 0
清除前100条消息 redis-cli -h 127.0.0.1 -p 6379 -n 1 ltrim key 100 -1
保留前100条消息 redis-cli -h 127.0.0.1 -p 6379 -n 1 ltrim key 0 100
删除：
删除当前库的所有数据
flushdb
删除所有库的所有数据
flushall
celery：
超时机制：
https://www.freebuf.com/column/216719.html
定时任务： 链接：https://blog.csdn.net/zhangfh1990/article/details/77164499
(1)
注意点：
定时任务其实就是拿一个装饰器 (@cel.on_after_configure.connect) 用来预留执行tasks任务，要执行定时任务需要额外执行 celery -A celery目名 beat
(2)
直接设置定义的Celery对象中的conf.beat_schedule属性就可以了
例子：
cel.conf.beat_schedule = {
'test': {
# 具体需要执行的函数
# 该函数必须要使用@app.task装饰
'task': 'celery_task.tasks1.test_celery',
# 定时时间
# 每分钟执行一次，不能为小数
# 'schedule': crontab(minute='*/1'),
'schedule': 10,
# 或者这么写，每小时执行一次
# "schedule": crontab(minute=0, hour="*/1")
# 执行的函数需要的参数
'args': ('测试定时',)
},
# 'test2': {
# 'task': 'celery5.celery_task.test2.test_celery2',
# # 设置定时的时间，10秒一次
# 'schedule': timedelta(seconds=5),
# 'args': ('测试')
# }
}
配置完后切记要运行 celery -A celery项目名 beat
Config配置名：链接：https://blog.csdn.net/tony10010/article/details/94578077
class Config:
# 包含以下两个任务文件，去相应的py文件中找任务，对多个任务做分类
BROKER_URL = 'redis://127.0.0.1:6379/1' #发布任务db
CELERY_RESULT_BACKEND = 'redis://127.0.0.1:6379/2' #任务结果db
CELERY_IMPORTS = [ #加载文件
'celery_task.tasks1',
'celery_task.tasks2',
'celery_task.tasks3',
]
失败重试： 链接：https://blog.csdn.net/yezi1993/article/details/89455716
@cel.task(bind=True) #bind=True 设置后会自动传入self，即task对象，
def test_celery(self,res):
# time.sleep(3)
try:
print('打印test_celery_1%s' % res)
assert 1==2
except Exception as e:
"""
邮件发送失败，使用retry进行重试
retry的参数可以有：
exc：指定抛出的异常
throw：重试时是否通知worker是重试任务
eta：指定重试的时间／日期
countdown：在多久之后重试（每多少秒重试一次）
max_retries：最大重试次数
"""
raise self.retry(exc=e, countdown=3, max_retries=5)
在任务中调用任务：
import celery
celery.current_app.send_task('celery_task.tasks2.test_celery2', args=['调用成功'])
Docker操作：
docker system prune 完整的系统清理，删除所有
https://www.jianshu.com/p/dd4a99222de2
docker pull XX 下载镜像
docker images 查看镜像
docker rmi [image] 删除镜像，-f, -force 强制删除镜像，以便有容器引用该镜像；-no-prune 不要删除未带标签的父镜像
docekr run image_id /bin/bash 创建容器
docker ps 查看启动的容器，加上-a是指查看所有容器
docker attach 镜像名字(container_id) 使用attach 进入容器操作，当在其里面使用了exit后，直接退出这个容器
docker exce
docker rm 删除容器
docker run --name container-name:tag -d -p 服务器端口:Docker 端口 image-name
--name:自定义容器名、-d:表示后台运行容器、image-name:指定运行的镜像名称以及Tag、-p表示进行服务器与docker容器的端口映射，
默认情况下容器中的镜像占用的端口是docker容器中的端口，与外界是隔离的，必须进行端口映射才能访问
docker ps -a -f status=exited 列出所有停止状态的容器
linux系统:
ssh-keygen的用法：链接参考： https://blog.csdn.net/qq_38570571/article/details/79268426
主要是为了使两个linux机器之间使用ssh不需要用户名和密码。采用了数字签名RSA或者DSA来完成这个操作。
linux有两个系列：
RedHat系列：Redhat、 Centos、Fendora等
Debian系列: Debian、Ubuntu等
RedHat系列：
1、常见的安装包格式rpm包，安装rpm包的命令是“rpm -参数”
2、包管理工具 yum
3、支持tar包
Debian系列:
1、常见的安装包格式 deb包，安装deb包的命令是“dpkg -参数”
2、包管理工具 apt-get
3、支持tar包
使用前要注意子的liunx系统是那个系列的
Debian：
aptitude 删除包以及它的所有依赖包
Centos:
vi编辑器:
保存命令：
按ESC进入命令模式
:w 保存但不退出
:w file 将修改另外保存到file中，不退出vi
:w! 强制保存，不退出vi
:wq 保存文件并退出vi
:wq! 强制保存文件，并退出vi
q: 不保存文件，退出vi
:q! 不保存文件，强制退出vi
:e! 放弃所有修改，从上次保存文件开始再编辑
yum list | grep postgresql 查看yum下载的所有包含 postgresql 的包
cat /etc/redhat-release 展示当前的系统版本
重启命令：
reboot 普通重启
shutdown -r now 立刻重启(root用户使用)
shutdown -r 10 过10分钟自动重启(root用户使用)
shutdown -r 20:35 在时间为20:35时候重启(root用户使用)
shutdown -c 命令取消重启
关机命令：
halt 立刻关机
poweroff 立刻关机
shutdown -h now 立刻关机(root用户使用)
shutdown -h 10 10分钟后自动关机
shutdown -c 命令取消重启
ll -h 展示当前文件大小，单位为k
ls 展示当前文件
( CentOS7 )
systemctl start XX.service 启动服务
systemctl stop XX.service 停止服务
systemctl restart XX.service 重启服务
systemctl status XX.service 查看服务状态
systemctl enable XX.service 设置开机启动
systemctl disable XX.service 设置开机不启动
systemctl is-active XX.service 查看服务是否运行
systemctl is-enable XX.service 查看服务是否设置为开机启动
systemctl mask XX.service 注销指定服务
systemctl unmask XX.service 取消注销指定服务
systemctl suspend 进入睡眠模式
systemctl hibemate 进入休眠模式
systemctl rescue 强制进入救援模式
systemctl emergency 强制进入紧急救援模式
systemctl [command] [unit.target] 设置运行级别
command：
get-default : 取得当前的target
set-default : 设置指定的target为默认的运行级别
isolate : 切换到指定的运行级别
unit.target : 为5.1表中列出的运行级别
运行级别对应表( 此外还是一个getty.target用来设置tty的数量 )
init级别 systemctl target
0 shutdown.target
1 emergency.target
2 rescure.target
3 multi-user.target
4 无
5 graphical.target
6 无
systemctl get-default 获取当前的运行级别
systemctl set-default multi-user.target 设置默认的运行级别为multi-user下
systemctl isolate multi-user.target 在不重启的情况下，切换到运行级别multi-user下
systemctl isolate graphical.target 在不重启的情况下，切换到图形界面下
systemctl list-dependencies [unit] [--reverse] 查看当前运行级别target( mult-user )启动了哪些服务
( --reverse 是用来检查哪个unit使用了这个unit )
systemctl list-units --all | grep sshd 查看开启的sshd服务
java IntelliJ IDEA:
下载：
https://www.jetbrains.com/idea/download/#section=windows #直接官方下载
创建项目：
对于小白，比较方便的就是先直接打开idea
选择创建新的项目，
进去选自定义，然后记得添加maven仓库，就会帮你直接生成好了；
要添加包，就打开pom.xml，在project标签下的dependencies标签中直接添加对应的dependency包的标签就可以了
快捷键：
ctrl + e 显示最近编辑的文件列表
shift + Click 关闭文件
ctrl + [ 或 ] 跳过大括号的开头结尾
ctrl + shift + 空格 跳转到上次编辑的地方
ctrl + F12 显示当前文件的结构
ctrl + F7 查询当前元素在当前文件中的引用，然后按F3可以选择
ctrl + N 快速打开类
ctrl + shift + N 快速打开文件
alt + q 看到当前方法的声明
ctrl + w 选择单词 继而 语句 继而 行 继而 函数
alt + F1 将正在编辑的元素在各个面板中定位
ctrl + p 显示参数信息
ctrl + shift + Insert 选择剪贴板内容并插入
alt + Insert 生成构造器/Getter/Setter等
ctrl + alt + v 引入变量。例如把括号内的SQL附成一个变量
ctrl + alt + t 把代码包在一块内，例如try/catch
ctrl + alt + b 找所有的子类
ctrl + shift + b 找变量的类
ctrl + g 定位行
ctrl + shift +r 在指定窗口替换文本
alt + shift + c 查找修改的文件
ctrl + e 最近打开的文件
F4 查找变量来源
ctrl + alt + F7 选中的字符查找工程出现的地方
ctrl + shift + o 弹出显示查找内容
使用maven仓库，打包成jar文件，要运行只需要环境中有对应java版本即可运行：
如果有maven的报错，就在maven仓库中的plugins标签中添加这一段：
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
如果这样也不行可以参考我自己的plugins:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<encoding>utf8</encoding>
<source>7</source>
<target>7</target>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
首先点击左上角file，选择project_structure ;
然后选择Artifacts，点击+，选择jar，再选择from modules .... ;
跳出弹框后，选择对应的main class，之后切记选择下面 MANIFEST.MF生成路径千万不能是 ....\main\java路径结尾的！！；
点击ok，ok。
再点击上面的Build选项，选择 Build Artifact ，再选择第一个build就可以了，
等待几秒钟，你的项目目录中就会生成一个out文件夹，点进去就有你生成好的jar文件了
运行jar命令是 java -jar 文件名.jar
java:
