postgresql、mysql自己整理txt的一些小知识（持续更新）_postgresql optimize table

自己随便整理了一些数据库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 "1634902916@qq.com"
	打开公钥：
		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 的路径 例如'git@a.coding.net:........'
	

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:
	

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300