MySQL on Dapeng Zhang

MySQL 替换字段中某几个字符并更新

Mon, 14 Jul 2025 16:28:12 +0000

mysql 替换字段中某几个字符并更新

UPDATE `database`.`table` 
SET `column` = REPLACE(column,'旧字符串','新字符串');

使用MySQL时如何精准查询慢SQL

Mon, 14 Jul 2025 14:44:56 +0000

使用MySQL时如何精准查询慢SQL

在做技术开发的过程中，当产品在访问量很大的情况下，如果发现数据库cpu或者iops飙升，那么可以看看是不是有慢sql

但是慢sql如何查询，需要我们一个一个查吗，这个比较耗费人力成本

不如我推荐一个命令

select * from information_schema.processlist where COMMAND <> 'Sleep';

经过这样的查询就能累出所有运行中的sql，这个时候就可以看到哪个sql执行时间长了，

正常情况下我们会遇到类似如下的输出

+-----+------+-----------+------+---------+------+-----------+----------------------------------------------+
| ID | USER | HOST | DB | COMMAND | TIME | STATE | INFO |
+-----+------+-----------+------+---------+------+-----------+----------------------------------------------+
| 106 | root | localhost | NULL | Query | 0 | executing | select * from information_schema.processlist |
+-----+------+-----------+------+---------+------+-----------+----------------------------------------------+

我们可以通过TIME判断出哪条sql执行时间比较久

MySQL存储过程与Laravel中使用方式

Fri, 11 Jul 2025 10:29:25 +0000

MySQL 5.0 版本开始支持存储过程。存储过程（Stored Procedure）是一种在数据库中存储复杂程序，以便外部程序调用的一种数据库对象。存储过程是为了完成特定功能的SQL语句集，经编译创建并保存在数据库中，用户可通过指定存储过程的名字并给定参数(需要时)来调用执行。

优点

1.存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般 SQL 语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度。

2.当对数据库进行复杂操作时(如对多个表进行 Update,Insert,Query,Delete 时），可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。这些操作，如果用程序来完成，就变成了一条条的 SQL 语句，可能要多次连接数据库。而换成存储，只需要连接一次数据库就可以了。

3.存储过程可以重复使用,可减少数据库开发人员的工作量。

4.安全性高,可设定只有某此用户才具有对指定存储过程的使用权。

缺点

1.如果更改范围大到需要对输入存储过程的参数进行更改，或者要更改由其返回的数据，则您仍需要更新程序集中的代码以添加参数、更新 GetValue() 调用，等等，这时候估计比较繁琐了。

2.可移植性差由于存储过程将应用程序绑定到 SQL Server，因此使用存储过程封装业务逻辑将限制应用程序的可移植性。如果应用程序的可移植性在您的环境中非常重要，则将业务逻辑封装在不特定于 RDBMS 的中间层中可能是一个更佳的选择。

3.大量采用存储过程进行业务逻辑的开发致命的缺点是很多存储过程不支持面向对象的设计，无法采用面向对象的方式将业务逻辑进行封装，从而无法形成通用的可支持复用的业务逻辑框架。

4.代码可读性差,相当难维护. 区别一，存储过程保存在数据库里面，存储过程可以被连接此数据库的所有程序设计语言和程序使用，自定义函数不能。

Laravel中如何使用

创建存储过程（两个参数，第一个参数为 activityid，第二个参数为 ids）

CREATE PROCEDURE update_records(IN activityid INTEGER ,ids text)
BEGIN
UPDATE wall_records SET activity_id = activityid
WHERE FIND_IN_SET (cid,ids); # 等于 where ids in ('1,2,3')
END;

代码调用

\DB::update('call update_records(1,"1,2,3")');

MySQL导出和导入记录

Fri, 04 Jul 2025 14:27:18 +0000

1、导出

mysqldump -u root -h 127.0.0.1 -p 库名称 > 文件名称.sql # 之后是要输入密码的别忘记了

如

mysqldump -u root -h 127.0.0.1 -p gowhich > gowhich_dump.sql # 之后是要输入密码的别忘记了

2、导入

登录mysql创建数据库

mysql -u root -h 127.0.0.1 -p # 之后是要输入密码的别忘记了

create databases gowhich # 如果你已经有了自己想要导入的库的话，就不需要这一步了

创建完库之后退出
执行

mysqldump -u root -h 127.0.0.1 -p 库名称 < 文件名称.sql # 之后是要输入密码的别忘记了

如

mysqldump -u root -h 127.0.0.1 -p gowhich < gowhich_dump.sql # 之后是要输入密码的别忘记了

登录mysql进行数据导入操作

mysql -u root -h 127.0.0.1 -p # 之后是要输入密码的别忘记了
source gowhich_dump.sql # 这一步是非常重要的一步
show database; # 查看数据库
show tables; # 查看数据库表

MySQL导入数据库失败的解决方法
参考链接：http://www.chinastor.com/a/jishu/mysqlbf/0G3GV2014.html

MySQL 查询分表方法【满足5.6.27版本】

Thu, 03 Jul 2025 11:07:50 +0000

业务需求，将record表做了分表处理，那么问题就出现了，以前的接口就有问题了。

SELECT * FROM record WHRER xxxx;

这样的SQL语句就不能正常执行了，只好不会再有新的数据进来了，结果不是需要的数据。

于是找了一个我认为算是比较笨拙，但是还能用的方法，就是使用union的方式查询。

SELECT * FROM (
 SELECT * FROM record_0 WHERE xxxx union
 SELECT * FROM record_1 WHERE xxxx union
 SELECT * FROM record_2 WHERE xxxx union
 SELECT * FROM record_3 WHERE xxxx union
 SELECT * FROM record_4 WHERE xxxx
) t WHERE xxx
GROUP BY xx
ORDER BY xx

你是否有更好的方法，可以跟我联系。

ALTER TABLE ... LOCK ... 的使用

Wed, 02 Jul 2025 15:40:35 +0000

来个示例，网上找了很久了，没发现同时添加多个字段的例子，我英文比较差，只能靠猜了，结果还真成了。

ALTER TABLE `record` 
	ADD COLUMN `rate_name` varchar(16) NOT NULL COMMENT '货币k值' AFTER `money`,
	ADD COLUMN `rate_money` decimal(16,4) NOT NULL COMMENT '货币汇率' AFTER `rate_name`,LOCK=SHARED;

ALTER TABLE `record_list` 
	ADD COLUMN `rate_name` varchar(16) NOT NULL COMMENT '货币K值' AFTER `mtime`,
	ADD COLUMN `rate_list` varchar(32) NOT NULL COMMENT '货币ID组合' AFTER `rate_name`,
	ADD COLUMN `list_rate_budget` decimal(16,4) NOT NULL COMMENT '预算汇率金额' AFTER `rate_list`,
	ADD COLUMN `date_start` bigint(20) NOT NULL COMMENT '起始日' AFTER `list_rate_budget`,LOCK=SHARED;

如下摘自原文档：https://dev.mysql.com/doc/refman/5.7/en/alter-table.html

LOCK = DEFAULT

Maximum level of concurrency for the given ALGORITHM clause (if any) and ALTER TABLE operation: Permit concurrent reads and writes if supported. If not, permit concurrent reads if supported. If not, enforce exclusive access.

LOCK = NONE

如果MYSQL支持, 则同时发生度读操作和写操作. Otherwise, return an error message.

LOCK = SHARED

如果MYSQL支持, 则允许并发读取但是阻塞写入。 Note that writes will be blocked even if concurrent writes are supported by the storage engine for the given ALGORITHM clause (if any) and ALTER TABLE operation. If concurrent reads are not supported, return an error message.

LOCK = EXCLUSIVE

实施独占访问. This will be done even if concurrent reads/writes are supported by the storage engine for the given ALGORITHM clause (if any) and ALTER TABLE operation

估计会翻译有误，不过大概意思是这样的

2015-09-10 工作记录

Tue, 01 Jul 2025 15:04:20 +0000

1、查看innodb死锁情况

查看事务情况

show engine innodb status\G

查看事务详情

SELECT * FROM information_schema.INNODB_TRX\G

2、kibana 4 添加图表，以及如何在dashboard【仪表板】上展示所有的图表或者分开展示图表

添加图表的流程一定要清楚，先要有visualization【可视化视图】，然后才能在dashboard【仪表板】上面添加图表，事实上图表就是所谓的

visualization【可视化视图】；

这里的操作关键比较难的是如何添加visualization【可视化视图】，并且在添加visualization【可视化视图】过程中的Filter的操作。

Filter说起来也很简单就是搜索出你要展示的数据数量的值，比如访问链接地址的时长，某个链接的请求次数的值。

关键是在添加visualization【可视化视图】过程中，先要选择视图的类型，然后就要对metrics和buckets的操作。

这里有一篇关于kibana4的图表入门：请点击这里

3、curl 指定用户以及密码访问

很简单：

curl -u user:password -XGET http://www.xxx.net/study/

就可以了.

4、通过python的线程实现异步发送邮件

from threading import Thread
def send_async_email(app, msg):
 with app.app_context():
 mail.send(msg)
def send_email(to, subject, template, **kwargs):
 msg = Message(app.config['FLASKY_MAIL_SUBJECT_PREFIX'] + subject,
 sender=app.config['FLASKY_MAIL_SENDER'], recipients=[to])
 msg.body = render_template(template + '.txt', **kwargs)
 msg.html = render_template(template + '.html', **kwargs)
 thr = Thread(target=send_async_email, args=[app, msg])
 thr.start()
 return thr

5、针对Flask项目初始化数据库

>>> from walkerfree import config
>>> from walkerfree import app
>>> app.config.from_object(config['development'])
>>> from walkerfree import db
>>> db.init_app(app)
>>> db
<SQLAlchemy engine='mysql+mysqldb://root:@127.0.0.1/walkerfree?charset=utf8'>
>>> db.create_all()

Scrapy 实现MySQLdb Pipline存储数据

Mon, 30 Jun 2025 14:09:07 +0000

这里使用的是MySQLdb-Python，用着还行，嘿嘿

代码看这里的

from scrapy.contrib.exporter import XmlItemExporter,JsonItemExporter,JsonLinesItemExporter,CsvItemExporter
from scrapy import signals,log
from scrapy.exceptions import DropItem
import datetime,pymongo
import MySQLdb
 
class MysqlDBPipline(object):
 def __init__(self,mysql_host,mysql_db,mysql_user,mysql_passwd):
 self.mysql_host = mysql_host
 self.mysql_db = mysql_db
 self.mysql_user = mysql_user
 self.mysql_passwd = mysql_passwd
 
 @classmethod
 def from_crawler(cls,crawler):
 return cls(
 mysql_host=crawler.settings.get('MYSQL_HOST'),
 mysql_user=crawler.settings.get('MYSQL_USER'),
 mysql_passwd=crawler.settings.get('MYSQL_PASSWD'),
 mysql_db=crawler.settings.get('MYSQL_DB')
 )
 
 def open_spider(self,spider):
 try:
 self.conn = MySQLdb.connect(
 user=self.mysql_user, 
 passwd=self.mysql_passwd, 
 db=self.mysql_db, 
 host=self.mysql_host, 
 charset="utf8", 
 use_unicode=True
 )
 self.cursor = self.conn.cursor()
 except MySQLdb.Error,e:
 print "Mysql Error %d: %s" % (e.args[0], e.args[1])
 
 def close_spider(self,spider):
 self.cursor.close()
 self.conn.close()
 
 def process_item(self,item,spider):
 valid = True
 for data in item:
 if not data:
 valid = False
 raise DropItem("Missing {0}!".format(data))
 
 if valid:
 for n in range(len(item['title'])):
 try:
 value = [item['title'][n],item['url'][n],item['create_time']]
 self.cursor.execute('INSERT INTO itunes (title,url,create_time) VALUES (%s,%s,%s)',value)
 self.conn.commit()
 except MySQLdb.Error,e:
 print "Mysql Error %d: %s" % (e.args[0], e.args[1])
 
 log.msg("Question added to MySQLdb database!", level=log.DEBUG, spider=spider)
 
 return item

配置文件加入

ITEM_PIPELINES = {
 'apple.pipelines.MysqlDBPipline':100
}

Flask中实现使用SQLAlchemy MySQLdb分页的程序逻辑

Mon, 30 Jun 2025 14:08:58 +0000

逻辑的话还是蛮简单的，多查看一个文档就可以了。代码如下

page = int(request.args.get('page')) if request.args.get('page') else 1
 pagesize = 20
 prev_page = page - 1 if page - 1 else 1
 next_page = page + 1
 
 # 关键字查询
 keywords = request.args.get('keywords')
 start_date = request.args.get('start_date') 
 end_date = request.args.get('end_date')
 
 params_query = {}
 query = Itunes.query
 if keywords:
 query = query.filter(Itunes.title.startswith(keywords))
 params_query['keywords'] = keywords
 
 if start_date and end_date:
 start = '%s 00:00:00' % start_date
 end = '%s 23:59:59' % end_date
 start = int(time.mktime(time.strptime(start,'%Y-%m-%d %H:%M:%S')))
 end = int(time.mktime(time.strptime(end,'%Y-%m-%d %H:%M:%S')))
 
 query = query.filter(Itunes.create_time > start)
 query = query.filter(Itunes.create_time <= end)
 
 params_query['start_date'] = start_date
 params_query['end_date'] = end_date
 
 if params_query: 
 itunes_sum = query.count()
 itunes = query.offset((page-1)*pagesize).limit(pagesize).all()
 else:
 itunes_sum = Itunes.query.count()
 itunes = Itunes.query.offset((page-1)*pagesize).limit(pagesize).all()
 
 
 
 return render_template(
 'front/spider_apple.html',
 itunes=itunes,
 itunes_sum=itunes_sum,
 title=u"Apple爬虫",
 prev_page=prev_page,
 next_page=next_page,
 params=params_query
 )

CentOS 安装php5.4.36+mysql5.5+apache2.4.10（二）

Mon, 30 Jun 2025 12:00:42 +0000

1、MySQL 源码安装

//================================

下载源码：

ftp://ftp.jaist.ac.jp/pub/mysql/Downloads/

此处下载：mysql-5.5.41.tar.gz

//================================下载安装cmake

http://www.cmake.org/files/v3.1/cmake-3.1.0.tar.gz

//================================编译安装cmake

./configure

//================================安装 ncurses ncurses-devel
yum install ncurses ncurses-devel
//================================创建mysql的安装目录及数据库存放目录
mkdir -p /usr/local/mysql
mkdir -p /usr/local/mysql/data
//================================创建mysql用户及用户组
groupadd mysql
useradd -r -g mysql mysql
//================================安装mysql
cmake . -DCMAKE_INSTALL_PREFIX=/usr/local/mysql -DMYSQL_DATADIR=/alidata/mysql/data -DDEFAULT_CHARSET=utf8 -DDEFAULT_COLLATION=utf8_general_ci -DEXTRA_CHARSETS=all -DENABLED_LOCAL_INFILE=1
//================================
make && make install
//================================设置目录权限
chown -R root:mysql .
chown -R mysql:mysql data
cp support-files/my-medium.cnf /etc/my.cnf
//================================创建系统数据库的表
scripts/mysql_install_db --user=mysql
//================================设置环境变量
vi /root/.bash_profile
//================================设置mysql启动服务
cp support-files/mysql.server /etc/init.d/mysqld
//================================修改MySQL的root用户的密码以及打开远程连接
mysql>use mysql;
mysql>desc user;
mysql> GRANT ALL PRIVILEGES ON *.* TO root@"%" IDENTIFIED BY "root";　　//为root添加远程连接的能力。
mysql>update user set Password = password('xxxxxx') where User='root';
mysql>select Host,User,Password from user where User='root'; 
mysql>flush privileges;
mysql>exit

2、安装apache2.4.10

//=================apr安装

yum remove apr-util-devel apr apr-util-mysql apr-docs apr-devel apr-util apr-util-doc
 
wget http://archive.apache.org/dist/apr/apr-1.4.5.tar.gz
wget http://archive.apache.org/dist/apr/apr-util-1.3.12.tar.gz 
wget http://jaist.dl.sourceforge.net/project/pcre/pcre/8.10/pcre-8.10.zip

以上第三个按照顺序解压安装

apache2.4.10编译安装使用如下命令

./configure --prefix=/usr/local/httpd --with-pcre=/usr/local/pcre --sysconfdir=/etc --enable-so --enable-rewrite && make && make install

3、安装php5.4.36

//安装gd扩展
wget http://liquidtelecom.dl.sourceforge.net/project/libpng/zlib/1.2.8/zlib-1.2.8.tar.gz
wget http://download.savannah.gnu.org/releases/freetype/freetype-2.4.0.tar.bz2
wget http://www.ijg.org/files/jpegsrc.v9.tar.gz
wget http://sourceforge.net/projects/libpng/files/libpng16/1.6.16/libpng-1.6.16.tar.gz/download
wget http://down1.chinaunix.net/distfiles/gd-2.0.32.tar.gz

按照上面的顺序依次安装

zlib安装

./configure --prefix=/usr/local/zlib --enable-shared && make && make install

freetype安装

./configure --prefix=/usr/local/freetype --enable-shared && make && make install

jpegsrc安装

./configure --prefix=/usr/local/jpeg --enable-shared && make && make install

libpng安装

./configure --prefix=/usr/local/libpng --enable-shared && make && make install

gd2安装

./configure --prefix=/usr/local/gd2 --enable-shared --with-zlib=/usr/local/zlib --with-freetype=/usr/local/freetype --with-jpeg=/usr/local/jpeg --with-png=/usr/local/png && make && make install

解压安装php//不解释

//================================

yum install libxml2
yum install libxml2-devel -y
//================================
./configure --prefix=/usr/local/php --with-config-file-path=/etc --with-gd --with-jpeg-dir=/usr/local/jpeg/ --with-png-dir=/usr/local/png/ --with-freetype-dir=/usr/local/freetype --with-zlib-dir=/usr/local/zlib/ --with-zlib --with-apxs2=/usr/local/httpd/bin/apxs --with-mysql=/usr/local/mysql --with-mysqli=mysqlnd --without-pear && make && make install

configure能正常通过，make配置到最后报错：make: *** [ext/gd/gd.lo] Error 1

据说这个错误是php5.4的bug:

解决方法

vim /usr/local/gd2/include/gd_io.h

gdIOCtx结构中增加void *data;

如下:

==========================================================

typedef struct gdIOCtx
{
 int (*getC) (struct gdIOCtx *);
 int (*getBuf) (struct gdIOCtx *, void *, int);
 
 void (*putC) (struct gdIOCtx *, int);
 int (*putBuf) (struct gdIOCtx *, const void *, int);
 
 int (*seek) (struct gdIOCtx *, const int);
 
 long (*tell) (struct gdIOCtx *);
 
 void (*gd_free) (struct gdIOCtx *);
 void (*data); //新增的内容
}
gdIOCtx;

Centos 安装php5.4.36+mysql5.5+apache2.4.10（一）

Mon, 30 Jun 2025 12:00:41 +0000

1、MySQL 源码安装
//================================
下载源码：
ftp://ftp.jaist.ac.jp/pub/mysql/Downloads/
此处下载：mysql-5.5.41.tar.gz
//================================
解压//不解释
//================================
下载编译文件
http://www.cmake.org/files/v3.1/cmake-3.1.0.tar.gz
//================================
编译安装cmake
//================================
安装 ncurses ncurses-devel
//================================
安装mysql
cmake . -DCMAKE_INSTALL_PREFIX=/usr/local/mysql -DMYSQL_DATADIR=/alidata/mysql/data -DDEFAULT_CHARSET=utf8 -DDEFAULT_COLLATION=utf8_general_ci -DEXTRA_CHARSETS=all -DENABLED_LOCAL_INFILE=1
//================================
make && make install
 
2、安装apache2.4.10
//=================apr安装
yum remove apr-util-devel apr apr-util-mysql apr-docs apr-devel apr-util apr-util-doc
 
wget http://archive.apache.org/dist/apr/apr-1.4.5.tar.gz
wget http://archive.apache.org/dist/apr/apr-util-1.3.12.tar.gz 
wget http://jaist.dl.sourceforge.net/project/pcre/pcre/8.10/pcre-8.10.zip
 
以上第三个按照顺序解压安装
apache2.4.10编译安装使用如下命令
./configure --prefix=/usr/local/apr
make && make install 
 
3、安装php5.4.36
 
//安装gd扩展
wget http://liquidtelecom.dl.sourceforge.net/project/libpng/zlib/1.2.8/zlib-1.2.8.tar.gz
wget http://download.savannah.gnu.org/releases/freetype/freetype-2.4.0.tar.bz2
wget http://www.ijg.org/files/jpegsrc.v9.tar.gz
wget http://sourceforge.net/projects/libpng/files/libpng16/1.6.16/libpng-1.6.16.tar.gz/download
wget http://down1.chinaunix.net/distfiles/gd-2.0.32.tar.gz
 
按照上面的顺序依次安装
zlib安装
./configure --prefix=/usr/local/zlib && make && make install
freetype安装
./configure --prefix=/usr/local/freetype && make && make install
jpegsrc安装
./configure --prefix=/usr/local/jpeg && make && make install
libpng安装
./configure --prefix=/usr/local/libpng && make && make install
gd2安装
./configure --prefix=/usr/local/gd2 --with-zlib=/usr/local/zlib --with-freetype-dir=/usr/local/freetype --with-jpeg-dir=/usr/local/jpeg --with-libpng-dir=/usr/local/libpng&& make && make install
 
解压安装php//不解释
//================================
yum install libxml2
yum install libxml2-devel -y
//================================
./configure --prefix=/usr/local/php --with-config-file-path=/etc --with-gd=/usr/local/gd2 --with-freetype-dir=/usr/local/freetype --with-apxs2=/usr/local/apache2/bin/apxs --with-mysql=/usr/local/mysql --with-mysqli=mysqlnd
//================================
make && make install

待续。。。

MySQL数据库没有任何用户的情况下，mysql如何恢复

Mon, 30 Jun 2025 12:00:40 +0000

service mysql stop

修改配置文件，添加一行代码

skip-grant-tables

然后重启mysql

service mysql start

接下来执行

mysql -p后面直接回车，就会进入mysql的命令行，然后依次执行如下命令

insert into mysql.user set user='root',ssl_cipher='',x509_issuer='',x509_subject='';

update mysql.user set Host='localhost',select_priv='y', insert_priv='y',update_priv='y', Alter_priv='y',delete_priv='y',create_priv='y',drop_priv='y',reload_priv='y',shutdown_priv='y',Process_priv='y',file_priv='y',grant_priv='y',References_priv='y',index_priv='y',create_user_priv='y',show_db_priv='y',super_priv='y',create_tmp_table_priv='y',Lock_tables_priv='y',execute_priv='y',repl_slave_priv='y',repl_client_priv='y',create_view_priv='y',show_view_priv='y',create_routine_priv='y',alter_routine_priv='y',create_user_priv='y' where user='root';

update mysql.user set password=password('123456') where user='root';

flush privileges;

MySQL查看和修改表的存储引擎

Mon, 30 Jun 2025 11:49:07 +0000

MySQL查看和修改表的存储引擎

//=================

给表添加注释

ALTER TABLE sk_subscribe COMMENT='预约记录表';

给表的字段【列】添加注释

ALTER table sk_products MODIFY `has_cash` BIGINT DEFAULT 0 COMMENT '已经募集的金额'

修改表的引擎

show engines;//查看支持的引擎
show table status from wycf where name='sk_productscate';//查看表引擎
alter table sk_productscate engine=Myisam;//修改表引擎

//修改数据库默认引擎

关闭mysql服务： net stop mysql

找到mysql安装目录下的my.ini文件：

找到default-storage-engine=INNODB 改为default-storage-engine=MYISAM

找到#skip-innodb 改为skip-innodb

启动mysql服务：net start mysql

MySQL服务性能优化—my.cnf配置说明详解

Fri, 27 Jun 2025 10:59:26 +0000

MYSQL服务器my.cnf配置文档详解
硬件：内存16G

[client] 
port = 3306 
socket = /data/3306/mysql.sock 
 
[mysql] 
no-auto-rehash 
 
[mysqld] 
user = mysql 
port = 3306 
socket = /data/3306/mysql.sock 
basedir = /usr/local/mysql 
datadir = /data/3306/data 
open_files_limit = 10240 
 
back_log = 600 
#在MYSQL暂时停止响应新请求之前，短时间内的多少个请求可以被存在堆栈中。如果系统在短时间内有很多连接，则需要增大该参数的值，该参数值指定到来的TCP/IP连接的监听队列的大小。默认值50。 
 
max_connections = 3000 
#MySQL允许最大的进程连接数，如果经常出现Too Many Connections的错误提示，则需要增大此值。 
 
max_connect_errors = 6000 
#设置每个主机的连接请求异常中断的最大次数，当超过该次数，MYSQL服务器将禁止host的连接请求，直到mysql服务器重启或通过flush hosts命令清空此host的相关信息。 
 
table_cache = 614 
#指示表调整缓冲区大小。# table_cache 参数设置表高速缓存的数目。每个连接进来，都会至少打开一个表缓存。#因此， table_cache 的大小应与 max_connections 的设置有关。例如，对于 200 个#并行运行的连接，应该让表的缓存至少有 200 × N ，这里 N 是应用可以执行的查询#的一个联接中表的最大数量。此外，还需要为临时表和文件保留一些额外的文件描述符。 
# 当 Mysql 访问一个表时，如果该表在缓存中已经被打开，则可以直接访问缓存；如果#还没有被缓存，但是在 Mysql 表缓冲区中还有空间，那么这个表就被打开并放入表缓#冲区；如果表缓存满了，则会按照一定的规则将当前未用的表释放，或者临时扩大表缓存来存放，使用表缓存的好处是可以更快速地访问表中的内容。执行 flush tables 会#清空缓存的内容。一般来说，可以通过查看数据库运行峰值时间的状态值 Open_tables #和 Opened_tables ，判断是否需要增加 table_cache 的值（其中 open_tables 是当#前打开的表的数量， Opened_tables 则是已经打开的表的数量）。即如果open_tables接近table_cache的时候，并且Opened_tables这个值在逐步增加，那就要考虑增加这个#值的大小了。还有就是Table_locks_waited比较高的时候，也需要增加table_cache。 
 
 
external-locking = FALSE 
#使用–skip-external-locking MySQL选项以避免外部锁定。该选项默认开启 
 
max_allowed_packet = 32M 
#设置在网络传输中一次消息传输量的最大值。系统默认值 为1MB，最大值是1GB，必须设置1024的倍数。 
 
sort_buffer_size = 2M 
# Sort_Buffer_Size 是一个connection级参数，在每个connection（session）第一次需要使用这个buffer的时候，一次性分配设置的内存。 
#Sort_Buffer_Size 并不是越大越好，由于是connection级的参数，过大的设置+高并发可能会耗尽系统内存资源。例如：500个连接将会消耗 500\*sort_buffer_size(8M)=4G内存 
#Sort_Buffer_Size 超过2KB的时候，就会使用mmap() 而不是 malloc() 来进行内存分配，导致效率降低。 
#技术导读 http://blog.webshuo.com/2011/02/16/mysql-sort_buffer_size/ 
#dev-doc: http://dev.mysql.com/doc/refman/5.5/en/server-parameters.html 
#explain select\*from table where order limit；出现filesort 
#属重点优化参数 
 
join_buffer_size = 2M 
#用于表间关联缓存的大小，和sort_buffer_size一样，该参数对应的分配内存也是每个连接独享。 
 
thread_cache_size = 300 
# 服务器线程缓存这个值表示可以重新利用保存在缓存中线程的数量,当断开连接时如果缓存中还有空间,那么客户端的线程将被放到缓存中,如果线程重新被请求，那么请求将从缓存中读取,如果缓存中是空的或者是新的请求，那么这个线程将被重新创建,如果有很多新的线程，增加这个值可以改善系统性能.通过比较 Connections 和 Threads_created 状态的变量，可以看到这个变量的作用。设置规则如下：1GB 内存配置为8，2GB配置为16，3GB配置为32，4GB或更高内存，可配置更大。 
 
thread_concurrency = 8 
# 设置thread_concurrency的值的正确与否, 对mysql的性能影响很大, 在多个cpu(或多核)的情况下，错误设置了thread_concurrency的值, 会导致mysql不能充分利用多cpu(或多核), 出现同一时刻只能一个cpu(或核)在工作的情况。thread_concurrency应设为CPU核数的2倍. 比如有一个双核的CPU, 那么thread_concurrency的应该为4; 2个双核的cpu, thread_concurrency的值应为8 
#属重点优化参数 
 
query_cache_size = 64M 
## 对于使用MySQL的用户，对于这个变量大家一定不会陌生。前几年的MyISAM引擎优化中，这个参数也是一个重要的优化参数。但随着发展，这个参数也爆露出来一些问题。机器的内存越来越大，人们也都习惯性的把以前有用的参数分配的值越来越大。这个参数加大后也引发了一系列问题。我们首先分析一下 query_cache_size的工作原理：一个SELECT查询在DB中工作后，DB会把该语句缓存下来，当同样的一个SQL再次来到DB里调用时，DB在该表没发生变化的情况下把结果从缓存中返回给Client。这里有一个关建点，就是DB在利用Query_cache工作时，要求该语句涉及的表在这段时间内没有发生变更。那如果该表在发生变更时，Query_cache里的数据又怎么处理呢？首先要把Query_cache和该表相关的语句全部置为失效，然后在写入更新。那么如果Query_cache非常大，该表的查询结构又比较多，查询语句失效也慢，一个更新或是Insert就会很慢，这样看到的就是Update或是Insert怎么这么慢了。所以在数据库写入量或是更新量也比较大的系统，该参数不适合分配过大。而且在高并发，写入量大的系统，建议把该功能禁掉。 
#重点优化参数（主库 增删改-MyISAM） 
 
query_cache_limit = 4M 
#指定单个查询能够使用的缓冲区大小，缺省为1M 
 
query_cache_min_res_unit = 2k 
#默认是4KB，设置值大对大数据查询有好处，但如果你的查询都是小数据查询，就容易造成内存碎片和浪费 
#查询缓存碎片率 = Qcache_free_blocks / Qcache_total_blocks \* 100% 
#如果查询缓存碎片率超过20%，可以用FLUSH QUERY CACHE整理缓存碎片，或者试试减小query_cache_min_res_unit，如果你的查询都是小数据量的话。 
#查询缓存利用率 = (query_cache_size – Qcache_free_memory) / query_cache_size \* 100% 
#查询缓存利用率在25%以下的话说明query_cache_size设置的过大，可适当减小;查询缓存利用率在80%以上而且Qcache_lowmem_prunes > 50的话说明query_cache_size可能有点小，要不就是碎片太多。 
#查询缓存命中率 = (Qcache_hits – Qcache_inserts) / Qcache_hits \* 100% 
 
default-storage-engine = MyISAM 
#default_table_type = InnoDB 
 
thread_stack = 192K 
#设置MYSQL每个线程的堆栈大小，默认值足够大，可满足普通操作。可设置范围为128K至4GB，默认为192KB。 
 
transaction_isolation = READ-COMMITTED 
# 设定默认的事务隔离级别.可用的级别如下: 
# READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE 
# 1.READ UNCOMMITTED-读未提交2.READ COMMITTE-读已提交3.REPEATABLE READ -可重复读4.SERIALIZABLE -串行 
 
tmp_table_size = 256M 
# tmp_table_size 的默认大小是 32M。如果一张临时表超出该大小，MySQL产生一个 The table tbl_name is full 形式的错误，如果你做很多高级 GROUP BY 查询，增加 tmp_table_size 值。如果超过该值，则会将临时表写入磁盘。 
max_heap_table_size = 256M 
long_query_time = 2 
log_long_format 
log-slow-queries=/data/3306/slow-log.log 
#log-bin = /data/3306/mysql-bin 
log-bin 
binlog_cache_size = 4M 
max_binlog_cache_size = 8M 
max_binlog_size = 512M 
 
expire_logs_days = 7 
key_buffer_size = 2048M 
#批定用于索引的缓冲区大小，增加它可以得到更好的索引处理性能，对于内存在4GB左右的服务器来说，该参数可设置为256MB或384MB。 
 
read_buffer_size = 1M 
# MySql读入缓冲区大小。对表进行顺序扫描的请求将分配一个读入缓冲区，MySql会为它分配一段内存缓冲区。read_buffer_size变量控制这一缓冲区的大小。如果对表的顺序扫描请求非常频繁，并且你认为频繁扫描进行得太慢，可以通过增加该变量值以及内存缓冲区大小提高其性能。和sort_buffer_size一样，该参数对应的分配内存也是每个连接独享。 
 
read_rnd_buffer_size = 16M 
# MySql的随机读（查询操作）缓冲区大小。当按任意顺序读取行时(例如，按照排序顺序)，将分配一个随机读缓存区。进行排序查询时，MySql会首先扫描一遍该缓冲，以避免磁盘搜索，提高查询速度，如果需要排序大量数据，可适当调高该值。但MySql会为每个客户连接发放该缓冲空间，所以应尽量适当设置该值，以避免内存开销过大。 
 
bulk_insert_buffer_size = 64M 
#批量插入数据缓存大小，可以有效提高插入效率，默认为8M 
 
myisam_sort_buffer_size = 128M 
# MyISAM表发生变化时重新排序所需的缓冲 
 
myisam_max_sort_file_size = 10G 
# MySQL重建索引时所允许的最大临时文件的大小 (当 REPAIR, ALTER TABLE 或者 LOAD DATA INFILE). 
# 如果文件大小比此值更大,索引会通过键值缓冲创建(更慢) 
 
myisam_max_extra_sort_file_size = 10G 
myisam_repair_threads = 1 
# 如果一个表拥有超过一个索引, MyISAM 可以通过并行排序使用超过一个线程去修复他们. 
# 这对于拥有多个CPU以及大量内存情况的用户,是一个很好的选择. 
 
myisam_recover 
#自动检查和修复没有适当关闭的 MyISAM 表 
skip-name-resolve 
lower_case_table_names = 1 
 
server-id = 1 
 
innodb_additional_mem_pool_size = 16M 
#这个参数用来设置 InnoDB 存储的数据目录信息和其它内部数据结构的内存池大小，类似于Oracle的library cache。这不是一个强制参数，可以被突破。 
 
innodb_buffer_pool_size = 2048M 
# 这对Innodb表来说非常重要。Innodb相比MyISAM表对缓冲更为敏感。MyISAM可以在默认的 key_buffer_size 设置下运行的可以，然而Innodb在默认的 innodb_buffer_pool_size 设置下却跟蜗牛似的。由于Innodb把数据和索引都缓存起来，无需留给操作系统太多的内存，因此如果只需要用Innodb的话则可以设置它高达 70-80% 的可用内存。一些应用于 key_buffer 的规则有 — 如果你的数据量不大，并且不会暴增，那么无需把 innodb_buffer_pool_size 设置的太大了 
 
innodb_data_file_path = ibdata1:1024M:autoextend 
#表空间文件 重要数据 
 
innodb_file_io_threads = 4 
#文件IO的线程数，一般为 4，但是在 Windows 下，可以设置得较大。 
 
innodb_thread_concurrency = 8 
#服务器有几个CPU就设置为几，建议用默认设置，一般为8. 
 
innodb_flush_log_at_trx_commit = 2 
# 如果将此参数设置为1，将在每次提交事务后将日志写入磁盘。为提供性能，可以设置为0或2，但要承担在发生故障时丢失数据的风险。设置为0表示事务日志写入日志文件，而日志文件每秒刷新到磁盘一次。设置为2表示事务日志将在提交时写入日志，但日志文件每次刷新到磁盘一次。 
 
innodb_log_buffer_size = 16M 
#此参数确定些日志文件所用的内存大小，以M为单位。缓冲区更大能提高性能，但意外的故障将会丢失数据.MySQL开发人员建议设置为1－8M之间 
 
innodb_log_file_size = 128M 
#此参数确定数据日志文件的大小，以M为单位，更大的设置可以提高性能，但也会增加恢复故障数据库所需的时间 
 
innodb_log_files_in_group = 3 
#为提高性能，MySQL可以以循环方式将日志文件写到多个文件。推荐设置为3M 
 
innodb_max_dirty_pages_pct = 90 
#推荐阅读 http://www.taobaodba.com/html/221_innodb_max_dirty_pages_pct_checkpoint.html 
# Buffer_Pool中Dirty_Page所占的数量，直接影响InnoDB的关闭时间。参数innodb_max_dirty_pages_pct 可以直接控制了Dirty_Page在Buffer_Pool中所占的比率，而且幸运的是innodb_max_dirty_pages_pct是可以动态改变的。所以，在关闭InnoDB之前先将innodb_max_dirty_pages_pct调小，强制数据块Flush一段时间，则能够大大缩短 MySQL关闭的时间。 
 
innodb_lock_wait_timeout = 120 
# InnoDB 有其内置的死锁检测机制，能导致未完成的事务回滚。但是，如果结合InnoDB使用MyISAM的lock tables 语句或第三方事务引擎,则InnoDB无法识别死锁。为消除这种可能性，可以将innodb_lock_wait_timeout设置为一个整数值，指示 MySQL在允许其他事务修改那些最终受事务回滚的数据之前要等待多长时间(秒数) 
 
innodb_file_per_table = 0 
#独享表空间（关闭） 
 
[mysqldump] 
quick 
max_allowed_packet = 32M 
 
[mysqld_safe] 
log-error=/data/3306/mysql_oldboy.err 
pid-file=/data/3306/mysqld.pid 
 
 
 
#补充 
#wait_timeout = 10 
#指定一个请求的最大连接时间，对于4GB左右的内存服务器来说，可以将其设置为5-10。 
#skip_networking 
#开启该选可以彻底关闭MYSQL的TCP/IP连接方式，如果WEB服务器是以远程连接的方式访问MYSQL数据库服务器的，则不要开启该选项，否则将无法正常连接。 
 
#log-queries-not-using-indexes 
将没有使用索引的查询也记录下来

我的配置my.cnf

# For advice on how to change settings please see
# http://dev.mysql.com/doc/refman/5.6/en/server-configuration-defaults.html

[mysqld]

# Remove leading # and set to the amount of RAM for the most important data
# cache in MySQL. Start at 70% of total RAM for dedicated server, else 10%.
# innodb_buffer_pool_size = 128M

# Remove leading # to turn on a very important data integrity option: logging
# changes to the binary log between backups.
# log_bin

# These are commonly set, remove the # and set as required.
basedir = /usr/local/mysql
datadir = /usr/local/mysql/data
port = 3306
server_id = 1
socket = /tmp/mysql.sock

skip-name-resolve

explicit_defaults_for_timestamp
lower_case_table_names=2

# Remove leading # to set options mainly useful for reporting servers.
# The server defaults are faster for transactions and fast SELECTs.
# Adjust sizes as needed, experiment to find the optimal values.
# join_buffer_size = 128M
# sort_buffer_size = 2M
# read_rnd_buffer_size = 2M 

[mysqld_safe]
log-error=/usr/local/mysql/error/mysql_safe.err
pid-file=/usr/local/mysql/pid/mysqld_safe.pid

sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES

转载：

http://www.linuxyw.com/a/shujuku/20130506/216.html

MySQL 错误解决“Could not find ./bin/my_print_defaults”

Fri, 27 Jun 2025 10:59:23 +0000

Mysql 错误解决“Could not find ./bin/my_print_defaults”

运行下面这条语句就可以搞定了。

sudo mysql_install_db --user=mysql --basedir=/usr/local/mysql --datadir=/usr/local/mysql/data &

MySQL批量修改表前缀

Fri, 27 Jun 2025 10:26:08 +0000

批量修改表名的操作方法:

SELECT CONCAT( 'ALTER TABLE ', TABLE_NAME, 'RENAME TO ', TABLE_NAME,';' )
FROM information_schema.TABLES
WHERE TABLE_NAME LIKE 'uc_%';

执行后得到如下的结果：

('ALTER TABLE uc_aaa RENAME TO uc_aaa;'),
('ALTER TABLE uc_bbb RENAME TO uc_bbb;')

导出结果到SQL文件中，然后去掉括号和引号，只保留如下的数据：

ALTER TABLE uc_aaa RENAME TO uc_aaa;
ALTER TABLE uc_bbb RENAME TO uc_bbb;

然后选择要修改的数据库，执行上面得到的SQL语句就可以了。
附：
1、批量删除指定前缀的表

SELECT CONCAT( 'drop table ', TABLE_NAME, ';' )
FROM information_schema.TABLES
WHERE TABLE_NAME LIKE 'uc_%';

2、“dbtable_name”改成“db_table_name”

SELECT CONCAT( 'ALTER TABLE ', TABLE_NAME, 'RENAME TO db_', SUBSTRING(TABLE_NAME,3),';' )
FROM information_schema.TABLES
WHERE TABLE_NAME LIKE 'db%';

参考文章：

http://www.islandcn.com/post/855.html

MySQL 去除字段中的换行和回车符

Tue, 24 Jun 2025 16:17:45 +0000

问题产生原因：

2种方法生成excel模式的报表：

1）手动生成

将表中的数据导出，生成CSV文件。

用mysqldump 导出数据

#mysqldump -u xxx -p --tab=/tmp/ --fields-terminated-by="#" DBName TBName

将会在tmp目录下生成TBName.txt 文件。

在EXCEL中导入生成的txt文件

2）直接生成csv格式文件

mysqldump -u samu -p -T --fields-terminated-by="," --fields-enclosed-by=""
--lines-terminated-by="\n" --fields-escaped-by="" test Customer

或者：

mysqldump -u samu -p --tab=/tmp/ --fields-terminated-by="," --fields-enclosed-by=""
--lines-terminated-by="\n" --fields-escaped-by="" test Customer

但是，无论上面哪一种方法，如果表的某个列里包含回车符或者换行符，
那么生成的CSV文件或者进行excel导入，都会将原本的1行数据，拆分成2行。
因为CSV或者excel导入，是按数据的行来认定数据条数。
所以，必须在此之前，将字段中的回车符或者换行符，进行替换。

强制修改MySQL的root密码

Tue, 24 Jun 2025 15:04:32 +0000

遇到了一个问题，就是我的Mysql的root密码忘记了，怎么办呢，赶快去google哇，哈

根据参考找到了一个

方法1：用SET PASSWORD命令

mysql -u root
mysql> SET PASSWORD FOR 'root'@'localhost' = PASSWORD('newpass');

方法2：用mysqladmin

mysqladmin -u root password "newpass"

如果root已经设置过密码，采用如下方法

mysqladmin -u root password oldpass "newpass"

方法3：用UPDATE直接编辑user表

mysql> use mysql;
mysql> UPDATE user SET Password = PASSWORD('newpass') WHERE user = 'root';
mysql> FLUSH PRIVILEGES;

方法4：在丢失root密码的时候，可以这样

mysql -u root mysql
mysql> UPDATE user SET password=PASSWORD("new password") WHERE user='root';
mysql> FLUSH PRIVILEGES;

在另外一个文章里面找到了上面第四个方法类似的，如下：

第一：首先要把mysqld停止

service mysqld stop

这里我在ubuntu上测试失败,如果没有用，可是试试下面的方法

/etc/init.d/mysql stop

第二：启动mysql，但是要跳过权限表

/usr/local/mysql/bin/mysqld_safe --skip-grant-tables &

我直接使用的是

mysqld_safe --skip-grant-tables &

第三：进去mysql，并修改密码

mysql -u root 
mysql>use mysql; 
mysql>update user set password=password("new_pass") where user="root"; 
mysql>flush privileges; 
mysql>\q

第四：重新启动mysql，正常进入

/etc/init.d/mysql start

参考文章：

http://www.linuxidc.com/Linux/2008-02/11137.htm

http://itindex.net/detail/36040-mysql-%E6%95%B0%E6%8D%AE%E5%BA%93-root

http://blog.csdn.net/phpandjava/article/details/4636610

MySQL: Pagination - SQL_CALC_FOUND_ROWS vs COUNT()-Query

Tue, 24 Jun 2025 15:04:25 +0000

关于Mysql的SQL_CALC_FOUND_ROWS的使用，网上有好多种说法，为了求证事实，google一搜索的话，就有好多，但是还是经过实际的测试才知道是不是好用或者不好用

When using pagination for let’s say a list of offers that where never clicked, you have to know the exact amount of offers (which were never clicked) in order to know how many pages you have. Now there are 2 possible ways of calculating the exact amount of offers: You can use either SQL_CALC_FOUND_ROWS or you can setup a second query with a COUNT() in it. I did the tests with SQL_NO_CACHE in order to get the best results possible. The clicks table has about 18.000.000 rows, the offer table about 800.000. Let’s start with some time results.

Using SQL_CALC_FOUND_ROWS（使用SQL_CALC_FOUND_ROWS进行的测试）

mysql> SELECT SQL_NO_CACHE SQL_CALC_FOUND_ROWS o.offer_id 
 -> FROM offer AS o 
 -> LEFT JOIN clicks AS c 
 -> ON (o.offer_id = c.offer_id) 
 -> WHERE c.offer_id IS NULL 
 -> LIMIT 50,50; 
50 rows in set (30.84 sec) 
 
mysql> SELECT FOUND_ROWS(); 
1 row in set (0.00 sec)

Using a second query with COUNT()（使用COUNT进行的测试）:

mysql> SELECT SQL_NO_CACHE o.offer_id 
 -> FROM offer AS o 
 -> LEFT JOIN clicks AS c 
 -> ON (o.offer_id = c.offer_id) 
 -> WHERE c.offer_id IS NULL 
 -> LIMIT 50,50; 
50 rows in set (0.03 sec)
 

mysql> SELECT SQL_NO_CACHE COUNT(o.offer_id) 
 -> FROM offer AS o 
 -> LEFT JOIN clicks AS c 
 -> ON (o.offer_id = c.offer_id) 
 -> WHERE c.offer_id IS NULL; 
1 row in set (30.97 sec)

对于上面的是普通的情况下，看看下面这种情况：

At a first glance they look equally fast, both taking about 30 seconds. But: They are only equally fast, when query caching is turned off. Let’s assume we’re on a high-traffic website where performance matters, so we turn the query cache on. MySQL Query caching is like a key-value cache with the key being the EXACT query and the resultset being the value. Once we turn on the cache, the pagination is way faster with the second query using COUNT().

为什么?

When using SQL_CALC_FOUND_ROWS the application has to calculate the found rows every single time we turn the page, because the query changes, while the COUNT()-Query always remains the same, meaning that its result comes from the query cache from the second time on. Let’s emulate:

Using SQL_CALC_FOUND_ROWS（使用SQL_CALC_FOUND_ROWS进行的测试）

mysql> SELECT SQL_CALC_FOUND_ROWS o.offer_id 
 -> FROM offer AS o 
 -> LEFT JOIN clicks AS c 
 -> ON (o.offer_id = c.offer_id) 
 -> WHERE c.offer_id IS NULL 
 -> LIMIT 50,50; 
50 rows in set (31.13 sec) 
 
mysql> SELECT FOUND_ROWS(); 
1 row in set (0.00 sec) 
 
mysql> SELECT SQL_CALC_FOUND_ROWS o.offer_id 
 -> FROM offer AS o 
 -> LEFT JOIN clicks AS c ON (o.offer_id = c.offer_id) 
 -> WHERE c.offer_id IS NULL 
 -> LIMIT 100,50; 
50 rows in set (30.71 sec) 
 
mysql> SELECT FOUND_ROWS(); 
1 row in set (0.00 sec)

Using a second query with COUNT()（使用COUNT进行的测试）

mysql> SELECT o.offer_id 
 -> FROM offer AS o 
 -> LEFT JOIN clicks AS c 
 -> ON (o.offer_id = c.offer_id) 
 -> WHERE c.offer_id IS NULL 
 -> LIMIT 50,50; 
50 rows in set (0.03 sec) 
 
mysql> SELECT COUNT(o.offer_id) 
 -> FROM offer AS o 
 -> LEFT JOIN clicks AS c 
 -> ON (o.offer_id = c.offer_id) 
 -> WHERE c.offer_id IS NULL; 
1 row in set (31.11 sec) 
 
mysql> SELECT o.offer_id 
 -> FROM offer AS o 
 -> LEFT JOIN clicks AS c 
 -> ON (o.offer_id = c.offer_id) 
 -> WHERE c.offer_id IS NULL 
 -> LIMIT 100,50; 
50 rows in set (0.04 sec) 
 
mysql> SELECT COUNT(o.offer_id) 
 -> FROM offer AS o 
 -> LEFT JOIN clicks AS c 
 -> ON (o.offer_id = c.offer_id) 
 -> WHERE c.offer_id IS NULL; 
1 row in set (0.00 sec)

While the SQL_CALC_FOUND_ROWS Queries took more than one minute together, the queries with the second COUNT() query only took a bit more than 30 seconds together, meaning they are twice as fast.

I’m pretty sure there are situations where SQL_CALC_FOUND_ROWS is the way to go, but in cases like this one you definately wanna go for the COUNT()-Query.

看出来了吧，其实网上大家的说法都是差不多的，也没有说不对或者对，因为如果加上一个前提的话，就很明显了，也说明，只有在一定的情况下才可以使用，不然不但不起作用，还会起到相反的作用

MySQL Case When的使用方法

Tue, 24 Jun 2025 15:04:22 +0000

关于Mysql Case When的使用方法，官方文档是这样写的

CASE case_value
 WHEN when_value THEN statement_list
 [WHEN when_value THEN statement_list] ...
 [ELSE statement_list]
END CASE

CASE
 WHEN search_condition THEN statement_list
 [WHEN search_condition THEN statement_list] ...
 [ELSE statement_list]
END CASE

有个注意事项是这样的：

Note

There is also a CASE expression, which differs from the CASE statement described here. See Section 12.4, “Control Flow Functions”. The CASE statement cannot have an ELSE NULL clause, and it is terminated with END CASE instead of END.

原文地址：http://dev.mysql.com/doc/refman/5.6/en/case.html

下面列举几个经常使用的方法

第一个：

select name, 
 case 
 when birthday<'1981' then 'old' 
 when birthday>'1988' then 'yong' 
 else 'ok' END YORN 
from lee;

第二个：

select NAME, 
 case name 
 when 'sam' then 'yong' 
 when 'lee' then 'handsome' 
 else 'good' end 
from lee;

第三个：

select name,birthday, 
 case 
 when birthday>'1983' then 'yong' 
 when name='lee' then 'handsome' 
 else 'just so so ' end 
from lee;

MySQL Insert的几点操作(DELAYED 、IGNORE、ON DUPLICATE KEY UPDATE )

Tue, 24 Jun 2025 11:24:31 +0000

INSERT语法

INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
 [INTO] tbl_name [(col_name,...)]
 VALUES ({expr | DEFAULT},...),(...),...
 [ ON DUPLICATE KEY UPDATE col_name=expr, ... ]

或：

INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
 [INTO] tbl_name
 SET col_name={expr | DEFAULT}, ...
 [ ON DUPLICATE KEY UPDATE col_name=expr, ... ]

或：

INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE]
 [INTO] tbl_name [(col_name,...)]
 SELECT ...
 [ ON DUPLICATE KEY UPDATE col_name=expr, ... ]

一、DELAYED 的使用

使用延迟插入操作

DELAYED调节符应用于INSERT和REPLACE语句。当DELAYED插入操作到达的时候，

服务器把数据行放入一个队列中，并立即给客户端返回一个状态信息，这样客户

端就可以在数据表被真正地插入记录之前继续进行操作了。如果读取者从该数据

表中读取数据，队列中的数据就会被保持着，直到没有读取者为止。接着服务器

开始插入延迟数据行（delayed-row）队列中的数据行。在插入操作的同时，服务器

还要检查是否有新的读取请求到达和等待。如果有，延迟数据行队列就被挂起，

允许读取者继续操作。当没有读取者的时候，服务器再次开始插入延迟的数据行。

这个过程一直进行，直到队列空了为止。

几点要注意事项：

INSERT DELAYED应该仅用于指定值清单的INSERT语句。服务器忽略用于INSERT DELAYED…SELECT语句的DELAYED。

服务器忽略用于INSERT DELAYED…ON DUPLICATE UPDATE语句的DELAYED。

因为在行被插入前，语句立刻返回，所以您不能使用LAST_INSERT_ID()来获取AUTO_INCREMENT值。AUTO_INCREMENT值可能由语句生成。

对于SELECT语句，DELAYED行不可见，直到这些行确实被插入了为止。

DELAYED在从属复制服务器中被忽略了，因为DELAYED不会在从属服务器中产生与主服务器不一样的数据。

注意，目前在队列中的各行只保存在存储器中，直到它们被插入到表中为止。这意味着，如果您强行中止了mysqld（例如，使用kill -9）

或者如果mysqld意外停止，则所有没有被写入磁盘的行都会丢失。

三、ON DUPLICATE KEY UPDATE的使用

如果您指定了ON DUPLICATE KEY UPDATE，并且插入行后会导致在一个UNIQUE索引或PRIMARY KEY中出现重复值，则执行旧行UPDATE。例如，如果列a被定义为UNIQUE，并且包含值1，则以下两个语句具有相同的效果：

mysql> INSERT INTO table (a,b,c) VALUES (1,2,3)
 -> ON DUPLICATE KEY UPDATE c=c+1;
mysql> UPDATE table SET c=c+1 WHERE a=1;

如果行作为新记录被插入，则受影响行的值为1；

如果原有的记录被更新，则受影响行的值为2。

注释：如果列b也是唯一列，则INSERT与此UPDATE语句相当：

mysql> UPDATE table SET c=c+1 WHERE a=1 OR b=2 LIMIT 1;

如果a=1 OR b=2与多个行向匹配，则只有一个行被更新。通常，您应该尽量避免对带有多个唯一关键字的表使用ON DUPLICATE KEY子句。

您可以在UPDATE子句中使用VALUES(col_name)函数从INSERT…UPDATE语句的INSERT部分引用列值。换句话说，如果没有发生重复关键字冲突，则UPDATE子句中的VALUES(col_name)可以引用被插入的col_name的值。本函数特别适用于多行插入。VALUES()函数只在INSERT…UPDATE语句中有意义，其它时候会返回NULL。

示例：

mysql> INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)
 -> ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);

本语句与以下两个语句作用相同：

mysql> INSERT INTO table (a,b,c) VALUES (1,2,3)
 -> ON DUPLICATE KEY UPDATE c=3;
mysql> INSERT INTO table (a,b,c) VALUES (4,5,6)
 -> ON DUPLICATE KEY UPDATE c=9;

当您使用ON DUPLICATE KEY UPDATE时，DELAYED选项被忽略。

总结：

DELAYED做为快速插入，并不是很关心失效性，提高插入性能。

IGNORE只关注主键对应记录是不存在，无则添加，有则忽略。

ON DUPLICATE KEY UPDATE 在添加时操作，关注非主键列，注意与ignore的区别。有则更新指定列，无则添加。

MySQL 删除数据 Delete 语句、Truncate 语句

Mon, 23 Jun 2025 15:27:44 +0000

如果数据库里面的数据有问题了，或者是有人捣乱，再或者就是您老人家看这条数据不爽，还有就是您想毁灭证据（其实总是会留下痕迹的）的时候，你就需要了解MySQL的Delete语句了。MySQL为我们提供了delete和truncate语句来删除数据。

delete 语句的定义：

经常和数据库打交道的孩子们，删除数据的时候用的大多都是 delete 语句。现在让我们来看一下 delete语句的定义。

DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM tbl_name
[WHERE where_definition]
[ORDER BY ...]
[LIMIT row_count]

delete 语句的示例：

MySQL的这些语法都和口语类似，你要指出你想从哪个表删除数据，还有删除哪些数据，这就够了。就像写记叙文的时候，时间、地点、人物、环境、情节几要素必不可少一样。

示例是最形象，最能说明问题的。按照上面的语法结构，我想删除 firends 表中所有 user_name 等于 simaopig 的记录，就可以使用如下SQL语句：

delete from friends where user_name = 'simaopig';

delete 注意事项：

从语法结构中，我们就可以看出，和 update 语法一样，我们是可以省略 where 子句的。不过这是一个很危险的行为。因为如果不指定 where 子句，delete 将删除表中所有的记录，而且是立即删除，即使你想哭都没有地方，也没有时间，因为你需要马上和主管承认错误，并且立即找出MySQL日志，来回滚记录。不过一旦你有过一次这样的经历，我相信这一定是印象深刻的。

truncate 语句的简单说明：

这个语句之前我也没有接触过，也没有使用过。因为一般情况下，删除数据大家都在使用delete语句。其实这个 truncate 命令很简单，它的意思是：删除表的所有记录。相当于 delete 语句不写 where 子句一样。其语法结构为：

TRUNCATE [TABLE] tbl_name

这里简单的给出个示例，我想删除 friends 表中所有的记录，可以使用如下语句：

truncate table friends;

truncate 和 delete的效率问题：

如果想要删除表的所有数据，truncate语句要比 delete 语句快。因为 truncate 删除了表，然后根据表结构重新建立它，而 delete 删除的是记录，并没有尝试去修改表。这也是为什么当向一个使用 delete 清空的表插入数据时，MySQL 会记住前面产生的AUTOINCREMENT序列，并且继续利用它对AUTOINCREMENT字段编号。而truncate删除表后，表是从1开始为autoincrement字段编号。

不过truncate命令快规快，却不像delete命令那样对事务处理是安全的。因此，如果我们想要执行truncate删除的表正在进行事务处理，这个命令就会产生退出并产生错误信息。

解决Lost connection to MySQL server at 'reading错误

Thu, 12 Jun 2025 17:45:14 +0000

当通过 TCP/IP 连接 MySQL 远程主机时，出现 ERROR 2013 (HY000): Lost connection to MySQL server at 'reading initial communication packet', system error: 104 。

如果是在linux shell命令行中直接打 mysql 命令，能够顺利连上 MySQL，执行查询语句也比较正常，但如果执行 STOP SLAVE; 命令时就随机出现 ERROR 2013 (HY000): Lost connection to MySQL server during query 问题。而如果把操作命令写到脚本文件再去执行该脚本文件的话，则必然出现 Lost connection to MySQL server at 'reading initial communication packet', system error: 111

要是无论通过什么途径远程访问都出现错误可以认为是系统有防火墙之类的限制，但现在这种奇怪的抽筋现象让人百思不得其解。最后找到的解决方法是在 my.cnf 里面的 [mysqld] 段增加一个启动参数skip-name-resolve 问题消失。但原因还是想不出所以然。

产生的原因是 my.cnf 中我设置了 skip-name-resolve，skip-name-resolve是禁用dns解析，所以在mysql的授权表中就不能使用主机名了，只能使用IP 。

MySQL创建字段的空格问题

Mon, 09 Jun 2025 18:10:19 +0000

下面举例子中空格我用【X】来表示

请看这条sql语句

INSERT INTO teleplay_tieba_daily
 (`t_t_id`,`sum`,`post_sum`,`subject_sum`,`member_sum`,`check_sum`,`yesterday_fans_num`, `yesterday_post_num`, `yesterday_subject_num`,`yesterday_member_num`, `yesterday_check_num`,`spider_date`)
 VALUES (236,1790,24728,1837,1790,17,0,0,0,0,0,'2013-04-22'),(240,239,6824,1082,239,5,0,0,0,0,0,'2013-04-22'),(5109,171,300,90,171,4,0,0,0,0,0,'2013-04-22'), (5139,97,2462,294,97,1,0,0,0,0,0,'2013-04-22'),(5153,36,1215,181,36,0,0,0,0,0,0,'2013-04-22'),(5276,26,759,115,26,0,0,0,0,0,0,'2013-04-22'),(5358,53,320,93,53,0,0,0,0,0,0,'2013-04-22'),(5387,3156,85687,4389,3156,54,0,0,0,0,0,'2013-04-22'),(5429,1181,13811,2430,1181,14,0,0,0,0,0,'2013-04-22'),(5480,46,749,117,46,0,0,0,0,0,0,'2013-04-22')

按道理说是没有问题的，但是给出的错误是：

Unknown column ‘yesterday_check_num’ in ‘field list’ 注意，是字段没有

反复看了一下，通过借助phpmyadmin的选择字段的方式添加数据，执行后，居然成功了

INSERT INTO teleplay_tieba_daily
 (`t_t_id`,`sum`,`post_sum`,`subject_sum`,`member_sum`,`check_sum`,`yesterday_fans_num`, `yesterday_post_num`,`yesterday_subject_num`, `yesterday_member_num`,`【x】yesterday_check_num`,`spider_date`)
 VALUES (236,1790,24728,1837,1790,17,0,0,0,0,0,'2013-04-22'),(240,239,6824,1082,239,5,0,0,0,0,0,'2013-04-22'),(5109,171,300,90,171,4,0,0,0,0,0,'2013-04-22'),(5139,97,2462,294,97,1,0,0,0,0,0,'2013-04-22'), (5153,36,1215,181,36,0,0,0,0,0,0,'2013-04-22'),(5276,26,759,115,26,0,0,0,0,0,0,'2013-04-22'),(5358,53,320,93,53,0,0,0,0,0,0,'2013-04-22'),(5387,3156,85687,4389,3156,54,0,0,0,0,0,'2013-04-22'),(5429,1181,13811,2430,1181,14,0,0,0,0,0,'2013-04-22'),(5480,46,749,117,46,0,0,0,0,0,0,'2013-04-22')

发现字段的真相是’【x】yesterday_check_num’，但是我想，我最初在创建字段的时候，为什么mysql没有把左右两边的空格过滤掉，这是漏洞还是mysql故意要这样设计的呢？如果有一天一个像我一样的程序员，也做了类似的事情，后面的程序员做sql插入的时候，估计会很困惑。因为这个问题，不去仔仔细细的查找，根本找不出原因。

另外程序员在处理输入的字符的时候都会将两边的空格去掉才对

Can't connect to MySQL server on 'xxx.xxx.xxx.xxx' (61)

Thu, 05 Jun 2025 17:37:45 +0000

我要在本机链接我本机上虚拟机的mysql，我使用mac下的workbench，就就是连接不上，报错信息为：“Can’t connect to MySQL server on ‘10.211.55.5’ (61)”，查了好多资料，有一种方法解决了我的问题：

第一步：查看是都3306端口开启使用ufw（不会安装的，请与我联系），

sudo ufw status

或者直接使用命令

netstat -an | grep 3306

如果结果显示类似：

tcp 0 0 127.0.0.1:3306 0.0.0.0:* LISTEN

从结果可以看出3306端口只是在IP 127.0.0.1上监听，所以拒绝了其他IP的访问。

第二步：修改配置文件修改文件 /etc/mysql/my.cnf文件，打开文件，找到下面内容：

# Instead of skip-networking the default is now to listen only on
# localhost which is more compatible and is not less secure.
bind-address = 127.0.0.1

把上面这一行注释掉或者把127.0.0.1换成合适的IP，建议注释掉。重新启动后，重新使用netstat检测：

~# netstat -an | grep 3306
tcp 0 0 0.0.0.0:3306 0.0.0.0:* LISTEN

第三步：

使用创建的用户登录一下，成功。

MySQL on Dapeng Zhang

MySQL 替换字段中某几个字符并更新

使用MySQL时如何精准查询慢SQL

MySQL存储过程与Laravel中使用方式

优点

缺点

Laravel中如何使用

MySQL导出和导入记录

MySQL 查询分表方法 【满足5.6.27版本】

ALTER TABLE ... LOCK ... 的使用

2015-09-10 工作记录

Scrapy 实现MySQLdb Pipline存储数据

Flask中实现使用SQLAlchemy MySQLdb分页的程序逻辑

CentOS 安装php5.4.36+mysql5.5+apache2.4.10（二）

Centos 安装php5.4.36+mysql5.5+apache2.4.10（一）

MySQL数据库没有任何用户的情况下，mysql如何恢复

MySQL查看和修改表的存储引擎

MySQL服务性能优化—my.cnf配置说明详解

MySQL 错误解决“Could not find ./bin/my_print_defaults”

MySQL批量修改表前缀

MySQL 去除字段中的换行和回车符

强制修改MySQL的root密码

MySQL: Pagination - SQL_CALC_FOUND_ROWS vs COUNT()-Query

MySQL Case When的使用方法

MySQL Insert的几点操作(DELAYED 、IGNORE、ON DUPLICATE KEY UPDATE )

MySQL 删除数据 Delete 语句 、Truncate 语句

解决Lost connection to MySQL server at 'reading错误

MySQL创建字段的空格问题

Can't connect to MySQL server on 'xxx.xxx.xxx.xxx' (61)

MySQL 查询分表方法【满足5.6.27版本】

MySQL 删除数据 Delete 语句、Truncate 语句