安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

安装后打开mysqld配置项
加入skip-grant-tables
可以无密码登录，登录进去后修改密码
修改成功删除skip-grant-tables

mysql> select user, plugin from mysql.user;
+-----------+-----------------------+
| user | plugin |
+-----------+-----------------------+
| root | auth_socket

mysql> update mysql.user set authentication_string=PASSWORD('newPwd'), plugin='mysql_native_password' where user='root';

sudo apt-get install mysql-server
sudo service mysql status
sudo service mysql stop/start/restart

user表登陆密码加密方式
mysql 8.0 修改了加密的插件方式，导致很多旧版本的navicat无法正常访问。为了方便访问，淡定创建一个原来加密方式的账号。
plugin修改为mysql_native_password
在我们用root访问时，需要注意老版本访问不了，所以修改plugin为老版本加密方式。

127.0.0.1和localhost 会匹配localhost
真实ip 匹配%

user表详解
https://blog.csdn.net/resilient/article/details/80796448

mysql增加用户
insert into user(host, user, authentication_string, ssl_cipher, x509_issuer, x509_subject) values("%", "kk", password("123456"), "", "","");

flush privileges;

修改用户权限
GRANT 权限 ON 数据库.* TO 用户名@'登录主机' IDENTIFIED BY '密码'
*.* 表示所有库的所有表
mylove.* 表示mylove库的所有表
mylove.loves 表示mylove库的loves表

设置编码为utf-8

在[client]下面加上: 客户端配置 mysql.cnf
default-character-set=utf8mb4

在[mysqld]下面加上: 服务端配置 mysqld.cnf
collation-server = utf8mb4_unicode_ci
character-set-server = utf8mb4
bind-address = 0.0.0.0

在[mysql]下添加: 这是为了啥？
default-character-set=utf8mb4

重启服务器:
service mysql restart

show variables like 'character_set_%'

MySQLdb连接时候指定编码，指定自动提交
c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

conv 参数 用于将返回的数据如何转换为python类型字段

from MySQLdb.constants import FIELD_TYPE
my_conv = { FIELD_TYPE.LONG: int }

FIELD_TYPE.LONG: 字段使用int函数转换，其他类似。

_mysql 的一些方法
ping 断开重连 mysqldb貌似不行，需要自己try 出错重新连接
query 执行
select_db 切换数据库
store_result 获取所有数据到client端，数据过大建议使用limit
use_result 一个一个从server端获取， 占用server连接，并且占用connection的通道
别人执行会覆盖数据
commit
rollback
set_character_set
get_character_set_info

fetch_row(maxrows, how) 最多获取多少行
how=1 default 返回tupple
how=2 返回字典 key冲突 加上表名 如 stu.name
how=3 返回字典 不管冲突如何 key全部返回表名加列名

mysqldb的一些方法

c = db.connect(host=host, user="kk", passwd="123456", db="test", charset="utf8", autocommit=True)

c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))

""" 三引号 便于分行描写sql，易于理解
execute 参数一 写入带%s的sql， 参数二列表形式给出具体数值

>> c.fetchone() 获取一行结果，没有返回表明读取完毕
(3L, 2L, 0L)

c.fetchmany(n) 返回n行结果
c.fetchall() 返回所有

此结果均被conv转换过了。

多句执行
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )

执行execute 务必加上try 保证正确执行

# 位置参数
cursor.execute('select * from students where id = %s', args=(10, ))

# 关键字参数
cursor.execute('select * from students where id = %(id)s', args={'id': 10})

1、set autocommit = 0

关闭当前会话中事务的自动提交，需要手动 commit 或者 rollback，相当于开启一个全局的事务。
首次自动begin，然后commit相当于重新自动begin

在 本地登录mysql 的的会话事务中，默认 autocommit = 1，每一次 sql 操作都被认为是一个单次的事务，被隐式提交

2、start transaction

挂起 autocommit 的状态，开启一个事务上下文。首先数据库会隐式提交之前的还未被提交的操作，同时开启一个新事务。挂起 autocommit 的意思是保存 autocommit 的当前状态，然后 start transaction，直到 commit or rollback 结束本次事务，再恢复之前挂起的 autocommit 的状态。

如果 start transaction 前 autocommit = 1，则完成本次事务后 autocommit 还是 1

如果 start transaction 前 autocommit = 0，则完成本次事务后 autocommit 还是 0，接下来的操作你仍需手动 commit 才可以提交

何时需要使用事务。

mysql根据配置文件会限制server接受的数据包大小。

有时候大的插入和更新会受max_allowed_packet 参数限制，导致写入或者更新失败。

当然还有其他高并发情况下，会出现插入更新失败的情况，此时必须要借助事务来保证一致性了。

oooooooooooooooo的更多相关文章

  1. Pictures of Ascii Art

    简述 指尖上的艺术 - 通过键盘上韵律般的敲敲打打,一幅幅美轮美奂的艺术作品便跃然于屏. 这样的画作,包含了无穷的创意,糅合了现代计算机科技与传统绘画艺术,难道还有比这更令人陶醉的美妙事物吗? 简述 ...

  2. C. Fox And Names

    C. Fox And Names time limit per test 2 seconds memory limit per test 256 megabytes input standard in ...

  3. CF Fox And Names (拓扑排序)

    Fox And Names time limit per test 2 seconds memory limit per test 256 megabytes input standard input ...

  4. （CodeForces 510C） Fox And Names 拓扑排序

    题目链接:http://codeforces.com/problemset/problem/510/C Fox Ciel is going to publish a paper on FOCS (Fo ...

  5. Fox And Names

    Description Fox Ciel is going to publish a paper on FOCS (Foxes Operated Computer Systems, pronounce ...

  6. 项目必备！永无 bug 注释

    佛祖保佑 永无bug 代码注释 // // _oo0oo_ // o8888888o // 88" . "88 // (| -_- |) // 0\ = /0 // ___/`-- ...

  7. 日常训练 dfs 之 拓扑排序

    今天被拓扑排序给折磨了一天,主要就是我的一个代码有点小bug,真难找... 先来看看我今天写的题目吧! C. Fox And Names Fox Ciel is going to publish a ...

  8. 佛祖保佑永无BUG代码注释

    // // _oo0oo_ // o8888888o // 88" . "88 // (| -_- |) // 0\ = /0 // ___/`---'\___ // .' \\| ...

  9. Codeforces Round #290 (Div. 2) 拓扑排序

    C. Fox And Names time limit per test 2 seconds memory limit per test 256 megabytes input standard in ...

随机推荐

  1. cd 切换目录

    1. 功能说明 cd是“change directory”中每个氮气的首字母缩写功能是重当前工作目录切换到指定的工作目录:cd是内建命令. 2. 语法格式 cd  [option]  [dir] cd ...

  2. Codeforces Round #595 (Div. 3) 题解

    前言 大家都在洛谷上去找原题吧,洛谷还是不错的qwq A 因为没有重复的数,我们只要将数据排序,比较两两之间有没有\(a_j - a_i == 1 (j > i)\) 的,有则输出 \(2\) ...

  3. BitMap位图

    BitMap位图算法https://blog.csdn.net/varyall/article/details/79662029 常见面试题 题1:在2.5亿个整数找出不重复的整数,内存不足以容纳着2 ...

  4. 关于<label>的for属性的简单探索

    在freecodecamp上HTML教程的Create a Set of Radio Buttons这一节中,看到这样一段话, It is considered best practice to se ...

  5. tomcat 部署指南

    下载与安装 个人建议不要使用发行版带的版本, 始终从主页来下载安装, 下载地址位于[1], 安装方法很简单, 直接解压即可, 建议解压到 /usr/local/ 目录, 再链接到 /usr/local ...

  6. NOIp 图论算法专题总结 (1)：最短路、最小生成树、最近公共祖先

    系列索引: NOIp 图论算法专题总结 (1) NOIp 图论算法专题总结 (2) NOIp 图论算法专题总结 (3) 最短路 Floyd 基本思路:枚举所有点与点的中点,如果从中点走最短,更新两点间 ...

  7. CAS 认证

    Central Authentication Service http session 保持机制 1.  用户向服务端发送密码,服务端生成与用户对应的 sessionid 2. 服务端将这个 sess ...

  8. 【CDN+】 Spark 的入门学习与运行流程

    前言 上文已经介绍了与Spark 息息相关的MapReduce计算模型,那么相对的Spark的优势在哪,有哪些适合大数据的生态呢? Spark对比MapReduce,Hive引擎,Storm流式计算引 ...

  9. 【OpenCV】 在CentOS下搭建OpenCV开发环境

    最近开始入模式识别的坑,自然被迫上OpenCV了. 在多次尝试给VS2015扩展Windows 10 SDK无果后(不要问我为啥..VS2015开发C++的标准库全给扔到这个SDK里了,打包在VS安装 ...

  10. Python算法每日一题--002--求众数

    给定一个大小为 n 的数组,找到其中的众数.众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素. 你可以假设数组是非空的,并且给定的数组总是存在众数. 示例 1: 输入: [3,2,3]输出: 3示 ...