配置中打开了记录慢查询，执行时间超过2秒的即为慢查询，系统显示有4148个慢查询，你可以分析慢查询日志，找出有问题的SQL语句，慢查询时间不宜设置过长，否则意义不大，最好在5秒以内，如果你需要微秒级别的慢查询，可以考虑给MySQL打补丁：http://www.percona.com/docs/wiki/release:start，记得找对应的版本。
　　打开慢查询日志可能会对系统性能有一点点影响，如果你的MySQL是主-从结构，可以考虑打开其中一台从服务器的慢查询日志，这样既可以监控慢查询，对系统性能影响又小。

　　二、连接数 
　　经常会遇见”MySQL: ERROR 1040: Too many connections”的情况，一种是访问量确实很高，MySQL服务器抗不住，这个时候就要考虑增加从服务器分散读压力，另外一种情况是MySQL配置文件中max_connections值过小： 
　　mysql> show variables like 'max_connections'; 
　　+-----------------+-------+ 
　　| Variable_name | Value | 
　　+-----------------+-------+ 
　　| max_connections | 256 | 
　　+-----------------+-------+　　

       这台MySQL服务器最大连接数是256，然后查询一下服务器响应的最大连接数： 
　　mysql> show global status like ‘Max_used_connections’;
　　MySQL服务器过去的最大连接数是245，没有达到服务器连接数上限256，应该没有出现1040错误，比较理想的设置是：
　　Max_used_connections / max_connections * 100% ≈ 85%
　　最大连接数占上限连接数的85%左右，如果发现比例在10%以下，MySQL服务器连接数上限设置的过高了。

　　三、Key_buffer_size 
　　key_buffer_size是对MyISAM表性能影响最大的一个参数，下面一台以MyISAM为主要存储引擎服务器的配置： 
　　mysql> show variables like ‘key_buffer_size’; 
　　+-----------------+------------+ 
　　| Variable_name | Value | 
　　+-----------------+------------+ 
　　| key_buffer_size | 536870912 | 
　　+-----------------+------------+　　

       分配了512MB内存给key_buffer_size，我们再看一下key_buffer_size的使用情况： 
　　mysql> show global status like 'key_read%'; 
　　+------------------------+-------------+ 
　　| Variable_name | Value | mysql 
　　+------------------------+-------------+ 
　　| Key_read_requests | 27813678764 | 
　　| Key_reads | 6798830 | 
　　+------------------------+-------------+　　

       一共有27813678764个索引读取请求，有6798830个请求在内存中没有找到直接从硬盘读取索引，计算索引未命中缓存的概率：
　　key_cache_miss_rate = Key_reads / Key_read_requests * 100%
　　比如上面的数据，key_cache_miss_rate为0.0244%，4000个索引读取请求才有一个直接读硬盘，已经很BT了,key_cache_miss_rate在0.1%以下都很好(每1000个请求有一个直接读硬盘)，如果key_cache_miss_rate在0.01%以下的话，key_buffer_size分配的过多，可以适当减少。
　　MySQL服务器还提供了key_blocks_*参数： 
　　mysql> show global status like 'key_blocks_u%'; 
　　+------------------------+-------------+ 
　　| Variable_name | Value | 
　　+------------------------+-------------+ 
　　| Key_blocks_unused | 0 | 
　　| Key_blocks_used | 413543 | 
　　+------------------------+-------------+　　

       Key_blocks_unused表示未使用的缓存簇(blocks)数，Key_blocks_used表示曾经用到的最大的blocks数，比如这台服务器，所有的缓存都用到了，要么增加key_buffer_size，要么就是过渡索引了，把缓存占满了。比较理想的设置： 
　　Key_blocks_used / (Key_blocks_unused + Key_blocks_used) * 100% ≈ 80%

　　四、临时表 
　　mysql> show global status like 'created_tmp%'; 
　　+-------------------------+---------+ 
　　| Variable_name | Value | 
　　+-------------------------+---------+ 
　　| Created_tmp_disk_tables | 21197 | 
　　| Created_tmp_files | 58 | 
　　| Created_tmp_tables | 1771587 | 
　　+-------------------------+---------+　　

       每次创建临时表，Created_tmp_tables增加，如果是在磁盘上创建临时表，Created_tmp_disk_tables也增加,Created_tmp_files表示MySQL服务创建的临时文件文件数，比较理想的配置是：
　　Created_tmp_disk_tables / Created_tmp_tables * 100% <= 25% 
　　比如上面的服务器Created_tmp_disk_tables / Created_tmp_tables * 100% = 1.20%，应该相当好了。我们再看一下MySQL服务器对临时表的配置： 
　　mysql> show variables where Variable_name in ('tmp_table_size', 'max_heap_table_size'); 
　　+---------------------+-----------+ 
　　| Variable_name | Value | 
　　+---------------------+-----------+ 
　　| max_heap_table_size | 268435456 | 
　　| tmp_table_size | 536870912 | 
　　+---------------------+-----------+　　

      只有256MB以下的临时表才能全部放内存，超过的就会用到硬盘临时表。
　　五、Open Table情况 
　　mysql> show global status like 'open%tables%'; 
　　+---------------+-------+ 
　　| Variable_name | Value | 
　　+---------------+-------+ 
　　| Open_tables | 919 | 
　　| Opened_tables | 1951 | 
　　+---------------+-------+　　

      Open_tables表示打开表的数量，Opened_tables表示打开过的表数量，如果Opened_tables数量过大，说明配置中table_cache(5.1.3之后这个值叫做table_open_cache)值可能太小，我们查询一下服务器table_cache值： 
　　mysql> show variables like 'table_cache'; 
　　+---------------+-------+ 
　　| Variable_name | Value | 
　　+---------------+-------+ 
　　| table_cache | 2048 | 
　　+---------------+-------+
　　比较合适的值为： 
　　Open_tables / Opened_tables * 100% >= 85%
　　Open_tables / table_cache * 100% <= 95%

　　六、进程使用情况
　　mysql> show global status like ‘Thread%’; 
　　+-------------------+-------+ 
　　| Variable_name | Value | 
　　+-------------------+-------+ 
　　| Threads_cached | 46 | 
　　| Threads_connected | 2 | 
　　| Threads_created | 570 | 
　　| Threads_running | 1 | 
　　+-------------------+-------+　　

      如果我们在MySQL服务器配置文件中设置了thread_cache_size，当客户端断开之后，服务器处理此客户的线程将会缓存起来以响应下一个客户而不是销毁(前提是缓存数未达上限)。Threads_created表示创建过的线程数，如果发现Threads_created值过大的话，表明MySQL服务器一直在创建线程，这也是比较耗资源，可以适当增加配置文件中thread_cache_size值，查询服务器thread_cache_size配置： 
　　mysql> show variables like 'thread_cache_size'; 
　　+-------------------+-------+ 
　　| Variable_name | Value | 
　　+-------------------+-------+ 
　　| thread_cache_size | 64 | 
　　+-------------------+-------+　　

      示例中的服务器还是挺健康的。

　　七、查询缓存(query cache) 
　　mysql> show global status like 'qcache%'; 
　　+-------------------------+-----------+ 
　　| Variable_name | Value | 
　　+-------------------------+-----------+ 
　　| Qcache_free_blocks | 22756 | 
　　| Qcache_free_memory | 76764704 | 
　　| Qcache_hits | 213028692 | 
　　| Qcache_inserts | 208894227 | 
　　| Qcache_lowmem_prunes | 4010916 | 
　　| Qcache_not_cached | 13385031 | 
　　| Qcache_queries_in_cache | 43560 | 
　　| Qcache_total_blocks | 111212 | 
　　+-------------------------+-----------+　　

       MySQL查询缓存变量解释：
　　Qcache_free_blocks：缓存中相邻内存块的个数。数目大说明可能有碎片。FLUSH QUERY CACHE会对缓存中的碎片进行整理，从而得到一个空闲块。
　　Qcache_free_memory：缓存中的空闲内存。 
　　Qcache_hits：每次查询在缓存中命中时就增大
　　Qcache_inserts：每次插入一个查询时就增大。命中次数除以插入次数就是不中比率。
　　Qcache_lowmem_prunes：缓存出现内存不足并且必须要进行清理以便为更多查询提供空间的次数。这个数字最好长时间来看;如果这个数字在不断增长，就表示可能碎片非常严重，或者内存很少。(上面的 free_blocks和free_memory可以告诉您属于哪种情况) 
　　Qcache_not_cached：不适合进行缓存的查询的数量，通常是由于这些查询不是 SELECT 语句或者用了now()之类的函数。
　　Qcache_queries_in_cache：当前缓存的查询(和响应)的数量。
　　Qcache_total_blocks：缓存中块的数量。
　　我们再查询一下服务器关于query_cache的配置： 
　　mysql> show variables like 'query_cache%'; 
　　+------------------------------+-----------+ 
　　| Variable_name | Value | 
　　+------------------------------+-----------+ 
　　| query_cache_limit | 2097152 | 
　　| query_cache_min_res_unit | 4096 | 
　　| query_cache_size | 203423744 | 
　　| query_cache_type | ON | 
　　| query_cache_wlock_invalidate | OFF |

       +——————————+———–+
　　各字段的解释：
　　query_cache_limit：超过此大小的查询将不缓存
　　query_cache_min_res_unit：缓存块的最小大小
　　query_cache_size：查询缓存大小
　　query_cache_type：缓存类型，决定缓存什么样的查询，示例中表示不缓存 select sql_no_cache 查询 
　　query_cache_wlock_invalidate：当有其他客户端正在对MyISAM表进行写操作时，如果查询在query cache中，是否返回cache结果还是等写操作完成再读表获取结果。
　　query_cache_min_res_unit的配置是一柄”双刃剑”，默认是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%
　　示例服务器 查询缓存碎片率 = 20.46%，查询缓存利用率 = 62.26%，查询缓存命中率 = 1.94%，命中率很差，可能写操作比较频繁吧，而且可能有些碎片。

　　八、排序使用情况 
　　mysql> show global status like 'sort%'; 
　　+-------------------+------------+ 
　　| Variable_name | Value | 
　　+-------------------+------------+ 
　　| Sort_merge_passes | 29 | 
　　| Sort_range | 37432840 | 
　　| Sort_rows | 9178691532 | 
　　| Sort_scan | 1860569 | 
　　+-------------------+------------+　　

       Sort_merge_passes 包括两步。MySQL 首先会尝试在内存中做排序，使用的内存大小由系统变量 Sort_buffer_size 决定，如果它的大小不够把所有的记录都读到内存中，MySQL 就会把每次在内存中排序的结果存到临时文件中，等 MySQL 找到所有记录之后，再把临时文件中的记录做一次排序。这再次排序就会增加 Sort_merge_passes。实际上，MySQL 会用另一个临时文件来存再次排序的结果，所以通常会看到 Sort_merge_passes 增加的数值是建临时文件数的两倍。因为用到了临时文件，所以速度可能会比较慢，增加 Sort_buffer_size 会减少 Sort_merge_passes 和 创建临时文件的次数。但盲目的增加 Sort_buffer_size 并不一定能提高速度，见 How fast can you sort data with MySQL?(引自http://qroom.blogspot.com/2007/09/mysql-select-sort.html，貌似被墙) mysql
　　另外，增加read_rnd_buffer_size(3.2.3是record_rnd_buffer_size)的值对排序的操作也有一点的好处，参见：http://www.mysqlperformanceblog.com/2007/07/24/what-exactly-is-read_rnd_buffer_size/

　　九、文件打开数(open_files) 
　　mysql> show global status like 'open_files'; 
　　+---------------+-------+ 
　　| Variable_name | Value | 
　　+---------------+-------+ 
　　| Open_files | 1410 | 
　　+---------------+-------+ 
　　mysql> show variables like 'open_files_limit'; 
　　+------------------+-------+ 
　　| Variable_name | Value | 
　　+------------------+-------+ 
　　| open_files_limit | 4590 | 
　　+------------------+-------+　　

      比较合适的设置：Open_files / open_files_limit * 100% <= 75%

　　十、表锁情况 
　　mysql> show global status like 'table_locks%'; 
　　+-----------------------+-----------+ 
　　| Variable_name | Value | 
　　+-----------------------+-----------+ 
　　| Table_locks_immediate | 490206328 | 
　　| Table_locks_waited | 2084912 | 
　　+-----------------------+-----------+　　

       Table_locks_immediate表示立即释放表锁数，Table_locks_waited表示需要等待的表锁数，如果Table_locks_immediate / Table_locks_waited > 5000，最好采用InnoDB引擎，因为InnoDB是行锁而MyISAM是表锁，对于高并发写入的应用InnoDB效果会好些。示例中的服务器Table_locks_immediate / Table_locks_waited = 235，MyISAM就足够了。

　　十一、表扫描情况 
　　mysql> show global status like 'handler_read%'; 
　　+-----------------------+-------------+ 
　　| Variable_name | Value | 
　　+-----------------------+-------------+ 
　　| Handler_read_first | 5803750 | 
　　| Handler_read_key | 6049319850 | 
　　| Handler_read_next | 94440908210 | 
　　| Handler_read_prev | 34822001724 | 
　　| Handler_read_rnd | 405482605 | 
　　| Handler_read_rnd_next | 18912877839 | 
　　+-----------------------+-------------+　　

        各字段解释参见http://hi.baidu.com/thinkinginlamp/blog/item/31690cd7c4bc5cdaa144df9c.html，调出服务器完成的查询请求次数： 
　　mysql> show global status like 'com_select'; 
　　+---------------+-----------+ 
　　| Variable_name | Value | 
　　+---------------+-----------+ 
　　| Com_select | 222693559 | 
　　+---------------+-----------+　　

       计算表扫描率：
　　表扫描率 = Handler_read_rnd_next / Com_select
　　如果表扫描率超过4000，说明进行了太多表扫描，很有可能索引没有建好，增加read_buffer_size值会有一些好处，但最好不要超过8MB。
　　后记： 
　　文中提到一些数字都是参考值，了解基本原理就可以，除了MySQL提供的各种status值外，操作系统的一些性能指标也很重要，比如常用的top,iostat等，尤其是iostat，现在的系统瓶颈一般都在磁盘IO上，关于iostat的使用.

CentOS7的yum源中默认好像是没有mysql的。为了解决这个问题，我们要先下载mysql的repo源。

1. 下载mysql的repo源

$ wget http://repo.mysql.com/mysql-community-release-el7-5.noarch.rpm

2. 安装mysql-community-release-el7-5.noarch.rpm包

$ sudo rpm -ivh mysql-community-release-el7-5.noarch.rpm

安装这个包后，会获得两个mysql的yum repo源：/etc/yum.repos.d/mysql-community.repo，/etc/yum.repos.d/mysql-community-source.repo。

3. 安装mysql

$ sudo yum install mysql-server

根据步骤安装就可以了，不过安装完成后，没有密码，需要重置密码。

4. 重置密码

重置密码前，首先要登录

$ mysql -u root

登录时有可能报这样的错：ERROR 2002 (HY000): Can‘t connect to local MySQL server through socket ‘/var/lib/mysql/mysql.sock‘ (2)，原因是/var/lib/mysql的访问权限问题。下面的命令把/var/lib/mysql的拥有者改为当前用户：

$ sudo chown -R openscanner:openscanner /var/lib/mysql

然后，重启服务：

$ service mysqld restart

接下来登录重置密码：

$ mysql -u root

mysql > use mysql;
mysql > update user set password=password(‘123456‘) where user=‘root‘;
mysql > exit;

5. 开放3306端口

$ sudo vim /etc/sysconfig/iptables

添加以下内容：

-A INPUT -p tcp -m state --state NEW -m tcp --dport 3306 -j ACCEPT

保存后重启防火墙：

$ sudo service iptables restart

这样从其它客户机也可以连接上mysql服务了。

1、安装MariaDB

安装命令

yum -y install mariadb mariadb-server

安装完成MariaDB，首先启动MariaDB

systemctl start mariadb

设置开机启动

systemctl enable mariadb

接下来进行MariaDB的相关简单配置

mysql_secure_installation

首先是设置密码，会提示先输入密码

Enter current password for root (enter for none):<–初次运行直接回车

设置密码

Set root password? [Y/n] <– 是否设置root用户密码，输入y并回车或直接回车
New password: <– 设置root用户的密码
Re-enter new password: <– 再输入一次你设置的密码

其他配置

Remove anonymous users? [Y/n] <– 是否删除匿名用户，回车

Disallow root login remotely? [Y/n] <–是否禁止root远程登录,回车,

Remove test database and access to it? [Y/n] <– 是否删除test数据库，回车

Reload privilege tables now? [Y/n] <– 是否重新加载权限表，回车

初始化MariaDB完成，接下来测试登录

mysql -uroot -ppassword

完成。

2、配置MariaDB的字符集

文件/etc/my.cnf

vi /etc/my.cnf

在[mysqld]标签下添加

init_connect='SET collation_connection = utf8_unicode_ci' init_connect='SET NAMES utf8' character-set-server=utf8 
collation-server=utf8_unicode_ci 
skip-character-set-client-handshake

文件/etc/my.cnf.d/client.cnf

vi /etc/my.cnf.d/client.cnf

在[client]中添加

default-character-set=utf8

文件/etc/my.cnf.d/mysql-clients.cnf

vi /etc/my.cnf.d/mysql-clients.cnf

在[mysql]中添加

default-character-set=utf8

 全部配置完成，重启mariadb

systemctl restart mariadb

之后进入MariaDB查看字符集

mysql> show variables like "%character%";show variables like "%collation%";

显示为

+--------------------------+----------------------------+
| Variable_name            | Value                      |
+--------------------------+----------------------------+
| character_set_client    | utf8                      |
| character_set_connection | utf8                      |
| character_set_database  | utf8                      |
| character_set_filesystem | binary                    |
| character_set_results    | utf8                      |
| character_set_server    | utf8                      |
| character_set_system    | utf8                      |
| character_sets_dir      | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.00 sec)

+----------------------+-----------------+
| Variable_name        | Value          |
+----------------------+-----------------+
| collation_connection | utf8_unicode_ci |
| collation_database  | utf8_unicode_ci |
| collation_server    | utf8_unicode_ci |
+----------------------+-----------------+
3 rows in set (0.00 sec)

字符集配置完成。

3、添加用户，设置权限

创建用户命令

mysql>create user username@localhost identified by 'password'; 

直接创建用户并授权的命令

mysql>grant all on *.* to username@localhost indentified by 'password';

授予外网登陆权限 

mysql>grant all privileges on *.* to username@'%' identified by 'password';

授予权限并且可以授权

mysql>grant all privileges on *.* to username@'hostname' identified by 'password' with grant option;

1.查看数据库

> db.stats();
{
    "db" : "test",               //当前数据库
    "collections" : 3,           //当前数据库多少表
    "objects" : 4,               //当前数据库所有表多少条数据
    "avgObjSize" : 51,           //每条数据的平均大小
    "dataSize" : 204,            //所有数据的总大小
    "storageSize" : 16384,       //所有数据占的磁盘大小
    "numExtents" : 3,
    "indexes" : 1,               //索引数
    "indexSize" : 8176,          //索引大小
    "fileSize" : 201326592,      //预分配给数据库的文件大小
    "nsSizeMB" : 16,
    "dataFileVersion" : {
        "major" : 4,
        "minor" : 5
    },
    "ok" : 1
}

2,查看数据库表

> db.test.stats();
{
    "ns" : "test.test",
    "count" : 1,
    "size" : 56,
    "avgObjSize" : 56,
    "storageSize" : 8192,
    "numExtents" : 1,
    "nindexes" : 1,
    "lastExtentSize" : 8192,
    "paddingFactor" : 1,
    "systemFlags" : 1,
    "userFlags" : 0,
    "totalIndexSize" : 8176,
    "indexSizes" : {
        "_id_" : 8176
    },
    "ok" : 1
}

数据备份mongodump

可以用mongodump 来做MongoDB 的库或表级别的备份，下面举例说明:
备份my_mongodb 数据库
[root@localhost bin]# ./mongodump -d my_mongodb
connected to: 127.0.0.1
DATABASE: my_mongodb to dump/my_mongodb
my_mongodb.system.indexes to dump/my_mongodb/system.indexes.bson
1 objects
my_mongodb.user to dump/my_mongodb/user.bson
2 objects
[root@localhost bin]# ll
总计 67648
-rwxr-xr-x 1 root root 7508756 2011-04-06 bsondump
drwxr-xr-x 3 root root 4096 04-10 23:54 dump
-rwxr-xr-x 1 root root 2978016 2011-04-06 mongo
此时会在当前目录下创建一个dump 目录，用于存放备份出来的文件
也可以指定备份存放的目录，

[root@localhost bin]# ./mongodump -d my_mongodb -o my_mongodb_dump
connected to: 127.0.0.1
DATABASE: my_mongodb to my_mongodb_dump/my_mongodb
my_mongodb.system.indexes to
my_mongodb_dump/my_mongodb/system.indexes.bson
1 objects
my_mongodb.user to my_mongodb_dump/my_mongodb/user.bson
2 objects
[root@localhost bin]#
这个例子中将备份的文件存在了当前目录下的my_mongodb_dump 目录下

数据恢复mongorestore

由于刚刚已经做了备份，所以我们先将库my_mongodb 删除掉
> use my_mongodb
switched to db my_mongodb
> db.dropDatabase()
{ "dropped" : "my_mongodb", "ok" : 1 }
> show dbs
admin (empty)
local (empty)
test (empty)
>
接下来我们进行数据库恢复
[root@localhost bin]# ./mongorestore -d my_mongodb my_mongodb_dump/*
connected to: 127.0.0.1
Wed Apr 11 00:03:03 my_mongodb_dump/my_mongodb/user.bson
Wed Apr 11 00:03:03 going into namespace [my_mongodb.user]
Wed Apr 11 00:03:03 2 objects found
Wed Apr 11 00:03:03 my_mongodb_dump/my_mongodb/system.indexes.bson
Wed Apr 11 00:03:03 going into namespace [my_mongodb.system.indexes]
Wed Apr 11 00:03:03 { name: "_id_", ns: "my_mongodb.user", key: { _id: 1 }, v: 0 }
Wed Apr 11 00:03:03 1 objects found
[root@localhost bin]#
经验证数据库又回来了，其实要是想恢复库，也大可不必先删除my_mongodb 库，只要指
明 –drop 参数，就可以在恢复的时候先删除表然后再向表中插入数据

一、导出工具mongoexport

Mongodb中的mongoexport工具可以把一个collection导出成JSON格式或CSV格式的文件。可以通过参数指定导出的数据项，也可以根据指定的条件导出数据。mongoexport具体用法如下所示：

[root@localhost mongodb]# ./bin/mongoexport --help
Export MongoDB data to CSV, TSV or JSON files.

options:
  --help                    produce help message
  -v [ --verbose ]          be more verbose (include multiple times for more 
                            verbosity e.g. -vvvvv)
  --version                 print the program's version and exit
  -h [ --host ] arg         mongo host to connect to ( <set name>/s1,s2 for 
                            sets)
  --port arg                server port. Can also use --host hostname:port
  --ipv6                    enable IPv6 support (disabled by default)
  -u [ --username ] arg     username
  -p [ --password ] arg     password
  --dbpath arg              directly access mongod database files in the given 
                            path, instead of connecting to a mongod  server - 
                            needs to lock the data directory, so cannot be used
                            if a mongod is currently accessing the same path
  --directoryperdb          if dbpath specified, each db is in a separate 
                            directory
  --journal                 enable journaling
  -d [ --db ] arg           database to use
  -c [ --collection ] arg   collection to use (some commands)
  -f [ --fields ] arg       comma separated list of field names e.g. -f 
                            name,age
  --fieldFile arg           file with fields names - 1 per line
  -q [ --query ] arg        query filter, as a JSON string
  --csv                     export to csv instead of json
  -o [ --out ] arg          output file; if not specified, stdout is used
  --jsonArray               output to a json array rather than one object per 
                            line
  -k [ --slaveOk ] arg (=1) use secondaries for export if available, default 
                            true

参数说明：

-h:指明数据库宿主机的IP

-u:指明数据库的用户名

-p:指明数据库的密码

-d:指明数据库的名字

-c:指明collection的名字

-f:指明要导出那些列

-o:指明到要导出的文件名

-q:指明导出数据的过滤条件

实例：test库中存在着一个students集合，集合中数据如下：

> db.students.find()
{ "_id" : ObjectId("5031143350f2481577ea81e5"), "classid" : 1, "age" : 20, "name" : "kobe" }
{ "_id" : ObjectId("5031144a50f2481577ea81e6"), "classid" : 1, "age" : 23, "name" : "nash" }
{ "_id" : ObjectId("5031145a50f2481577ea81e7"), "classid" : 2, "age" : 18, "name" : "james" }
{ "_id" : ObjectId("5031146a50f2481577ea81e8"), "classid" : 2, "age" : 19, "name" : "wade" }
{ "_id" : ObjectId("5031147450f2481577ea81e9"), "classid" : 2, "age" : 19, "name" : "bosh" }
{ "_id" : ObjectId("5031148650f2481577ea81ea"), "classid" : 2, "age" : 25, "name" : "allen" }
{ "_id" : ObjectId("5031149b50f2481577ea81eb"), "classid" : 1, "age" : 19, "name" : "howard" }
{ "_id" : ObjectId("503114a750f2481577ea81ec"), "classid" : 1, "age" : 22, "name" : "paul" }
{ "_id" : ObjectId("503114cd50f2481577ea81ed"), "classid" : 2, "age" : 24, "name" : "shane" }

由上可以看出文档中存在着3个字段：classid、age、name

1.直接导出数据到文件中

[root@localhost mongodb]# ./bin/mongoexport -d test -c students -o students.dat
connected to: 127.0.0.1
exported 9 records

命令执行完后使用ll命令查看，发现目录下生成了一个students.dat的文件

[root@localhost mongodb]# ll
-rw-r--r-- 1 root root   869 Aug 21 00:05 students.dat

查看该文件信息，具体信息如下：

[root@localhost mongodb]# cat students.dat 
{ "_id" : { "$oid" : "5031143350f2481577ea81e5" }, "classid" : 1, "age" : 20, "name" : "kobe" }
{ "_id" : { "$oid" : "5031144a50f2481577ea81e6" }, "classid" : 1, "age" : 23, "name" : "nash" }
{ "_id" : { "$oid" : "5031145a50f2481577ea81e7" }, "classid" : 2, "age" : 18, "name" : "james" }
{ "_id" : { "$oid" : "5031146a50f2481577ea81e8" }, "classid" : 2, "age" : 19, "name" : "wade" }
{ "_id" : { "$oid" : "5031147450f2481577ea81e9" }, "classid" : 2, "age" : 19, "name" : "bosh" }
{ "_id" : { "$oid" : "5031148650f2481577ea81ea" }, "classid" : 2, "age" : 25, "name" : "allen" }
{ "_id" : { "$oid" : "5031149b50f2481577ea81eb" }, "classid" : 1, "age" : 19, "name" : "howard" }
{ "_id" : { "$oid" : "503114a750f2481577ea81ec" }, "classid" : 1, "age" : 22, "name" : "paul" }
{ "_id" : { "$oid" : "503114cd50f2481577ea81ed" }, "classid" : 2, "age" : 24, "name" : "shane" }

参数说明：

-d:指明使用的库，本例中为test

-c:指明要导出的集合，本例中为students

-o:指明要导出的文件名，本例中为students.dat

从上面的结果可以看出，我们在导出数据时没有显示指定导出样式 ，默认导出了JSON格式的数据。如果我们需要导出CSV格式的数据，则需要使用--csv参数，具体如下所示：

[root@localhost mongodb]# ./bin/mongoexport -d test -c students --csv -f classid,name,age -o students_csv.dat
connected to: 127.0.0.1
exported 9 records
[root@localhost mongodb]# cat students_csv.dat 
classid,name,age
1.0,"kobe",20.0
1.0,"nash",23.0
2.0,"james",18.0
2.0,"wade",19.0
2.0,"bosh",19.0
2.0,"allen",25.0
1.0,"howard",19.0
1.0,"paul",22.0
2.0,"shane",24.0
[root@localhost mongodb]# 

参数说明：

-csv：指明要导出为csv格式

-f：指明需要导出classid、name、age这3列的数据

由上面结果可以看出，mongoexport成功地将数据根据csv格式导出到了students_csv.dat文件中。

二、导入工具mongoimport

Mongodb中的mongoimport工具可以把一个特定格式文件中的内容导入到指定的collection中。该工具可以导入JSON格式数据，也可以导入CSV格式数据。具体使用如下所示：

[root@localhost mongodb]# ./bin/mongoimport --help
options:
  --help                  produce help message
  -v [ --verbose ]        be more verbose (include multiple times for more 
                          verbosity e.g. -vvvvv)
  --version               print the program's version and exit
  -h [ --host ] arg       mongo host to connect to ( <set name>/s1,s2 for sets)
  --port arg              server port. Can also use --host hostname:port
  --ipv6                  enable IPv6 support (disabled by default)
  -u [ --username ] arg   username
  -p [ --password ] arg   password
  --dbpath arg            directly access mongod database files in the given 
                          path, instead of connecting to a mongod  server - 
                          needs to lock the data directory, so cannot be used 
                          if a mongod is currently accessing the same path
  --directoryperdb        if dbpath specified, each db is in a separate 
                          directory
  --journal               enable journaling
  -d [ --db ] arg         database to use
  -c [ --collection ] arg collection to use (some commands)
  -f [ --fields ] arg     comma separated list of field names e.g. -f name,age
  --fieldFile arg         file with fields names - 1 per line
  --ignoreBlanks          if given, empty fields in csv and tsv will be ignored
  --type arg              type of file to import.  default: json (json,csv,tsv)
  --file arg              file to import from; if not specified stdin is used
  --drop                  drop collection first 
  --headerline            CSV,TSV only - use first line as headers
  --upsert                insert or update objects that already exist
  --upsertFields arg      comma-separated fields for the query part of the 
                          upsert. You should make sure this is indexed
  --stopOnError           stop importing at first error rather than continuing
  --jsonArray             load a json array, not one item per line. Currently 
                          limited to 4MB.

参数说明：

-h:指明数据库宿主机的IP

-u:指明数据库的用户名

-p:指明数据库的密码

-d:指明数据库的名字

-c:指明collection的名字

-f:指明要导入那些列

示例：先删除students中的数据，并验证

> db.students.remove()
> db.students.find()
> 

然后再导入上面导出的students.dat文件中的内容

[root@localhost mongodb]# ./bin/mongoimport -d test -c students students.dat 
connected to: 127.0.0.1
imported 9 objects
[root@localhost mongodb]# 

参数说明：

-d:指明数据库名，本例中为test

-c:指明collection名，本例中为students

students.dat：导入的文件名

查询students集合中的数据

> db.students.find()
{ "_id" : ObjectId("5031143350f2481577ea81e5"), "classid" : 1, "age" : 20, "name" : "kobe" }
{ "_id" : ObjectId("5031144a50f2481577ea81e6"), "classid" : 1, "age" : 23, "name" : "nash" }
{ "_id" : ObjectId("5031145a50f2481577ea81e7"), "classid" : 2, "age" : 18, "name" : "james" }
{ "_id" : ObjectId("5031146a50f2481577ea81e8"), "classid" : 2, "age" : 19, "name" : "wade" }
{ "_id" : ObjectId("5031147450f2481577ea81e9"), "classid" : 2, "age" : 19, "name" : "bosh" }
{ "_id" : ObjectId("5031148650f2481577ea81ea"), "classid" : 2, "age" : 25, "name" : "allen" }
{ "_id" : ObjectId("5031149b50f2481577ea81eb"), "classid" : 1, "age" : 19, "name" : "howard" }
{ "_id" : ObjectId("503114a750f2481577ea81ec"), "classid" : 1, "age" : 22, "name" : "paul" }
{ "_id" : ObjectId("503114cd50f2481577ea81ed"), "classid" : 2, "age" : 24, "name" : "shane" }
> 

证明数据导入成功

上面演示的是导入JSON格式的文件中的内容，如果要导入CSV格式文件中的内容，则需要通过--type参数指定导入格式，具体如下所示：

先删除数据

> db.students.remove()
> db.students.find()
> 

 再导入之前导出的students_csv.dat文件

[root@localhost mongodb]# ./bin/mongoimport -d test -c students --type csv --headerline --file students_csv.dat 
connected to: 127.0.0.1
imported 10 objects
[root@localhost mongodb]# 

参数说明：

-type:指明要导入的文件格式

-headerline:指明第一行是列名，不需要导入

-file：指明要导入的文件

查询students集合，验证导入是否成功：

> db.students.find()
{ "_id" : ObjectId("503266029355c632cd118ad8"), "classid" : 1, "name" : "kobe", "age" : 20 }
{ "_id" : ObjectId("503266029355c632cd118ad9"), "classid" : 1, "name" : "nash", "age" : 23 }
{ "_id" : ObjectId("503266029355c632cd118ada"), "classid" : 2, "name" : "james", "age" : 18 }
{ "_id" : ObjectId("503266029355c632cd118adb"), "classid" : 2, "name" : "wade", "age" : 19 }
{ "_id" : ObjectId("503266029355c632cd118adc"), "classid" : 2, "name" : "bosh", "age" : 19 }
{ "_id" : ObjectId("503266029355c632cd118add"), "classid" : 2, "name" : "allen", "age" : 25 }
{ "_id" : ObjectId("503266029355c632cd118ade"), "classid" : 1, "name" : "howard", "age" : 19 }
{ "_id" : ObjectId("503266029355c632cd118adf"), "classid" : 1, "name" : "paul", "age" : 22 }
{ "_id" : ObjectId("503266029355c632cd118ae0"), "classid" : 2, "name" : "shane", "age" : 24 }
> 

 说明已经导入成功 

一、MongoDB介绍
MongoDB 是一种 NoSQL 非关系型数据库。MongoDB 有 database 组成（相关于关系型数据库的数据库）。database 有 collection(相当于关系型数据库的数据库表Table). collection 有 document(文档)组成 （相当于关系型数据库的数据行记录Record），document 有 filed 组成(相当于关系型数据库的数据列字段filed)

二、MongoDB下载和安装
MongoDB官方地址：http://www.mongodb.org/downloads
MongoDB安装：
LINUX版本：
#mkdir -p /MongoDB/db 创建数据目录
#mkdir -p /MongoDB/logs  创建日志目录

#tar -zxvf mongodb-linux-x86_64-1.2.4.tgz 解压开安装包
./mongod -fork --dbpath=/MongoDB/db/ --logpath=/MongoDB/logs/MongoDB.log  --logappend --port=27017 &  启动服务器。

WINDOW版本：
执行如下命令启动服务器:
mongod --bind_ip 127.0.0.1 --logpath d:\MongoDB\logs --logappend --dbpath d:\MongoDB\db  --directoryperdb –install
【注：将mongodb安装成服务，装该服务绑定到IP127.0.0.1，日志文件为d:\MongoDB\logs，以及添加方式记录。数据目录为d:\MongoDB\db。并且每个数据库将储存在一个单独的目录（--directoryperdb）】

三、客户端使用：
　　LINUX版本：
　　进入MongoDB的bin目录下，使用./mongo进入命令行行下  然后即可进行增删改查等日常操作。
　　WINDOW版本：
　　进入mongodb的bin目录下，使用mongo.exe --host IP  --port 端口连接到MongoDB服务器上

四、MongDB停止
　　LINUX版本：
　　      如果在shell窗口下可以直接按“CTRL+C”，如果是作为后台服务使用时，可以先使用  ps -ef |grep mongod查询出服务器的pid，然后使用kill -9 pid    此处的Pid为查询出的pid。
　　WINDOW版本：
　　       如果在命令窗口下直接按“CTRL+C”，如果是作为系统服务来使用的话，需要到服务管理中停止服务或者在window管理器中终止进程。

五、web版本的统计服务状态
    使用http://IP（服务器IP）:端口即可

六、MongoDB使用

#/usr/local/mongodb/bin/mongo 192.168.1.100:10000 (mongo --host IP  --port 连接服务器，如果本机默认端口不需要任何参数即可) 
MongoDB shell version: 2.2.0
connecting to: 192.168.1.100:10000/test

//列出数据库
> show dbs;
demodb  0.203125GB
test    (empty)


//切换数据库
> use demodb; 
switched to db demodb


//列出数据集合
>show collections; 
system.indexes
test

//插入数据
>db.test.insert({'name':'test01','age':25})  <==>insert into test ('name','age') values('test01',25)
>db.test.insert({'name':'test02','age':30})  <==>insert into test ('name','age') values('test02',30)  

//查询数据
>db.test.find();   <==>select * from test
{ "_id" : ObjectId("52f5abedd6b74b058a8de84f"), "name" : "test01", "age" : 25 }
{ "_id" : ObjectId("52f5abedd6b74b058a8de86d"), "name" : "test02", "age" : 30 }

>db.test.find({'age':{$in:[25,35]}}) <==> select * from test where age in (25,35)

 


//更新数据
>db.test.update({'name':'test02'},{$set:{age:32}});   <==>update test set age=32 where name='test02' (更新一条数据)
>db.test.update({'name':'test02'},{$set:{age:32}},false,true);   <==>update test set age=32 where name='test02' （更新所有数据）


//更新数值增减
>db.test.update({'name':'test01'},{$inc:{age:-1}});   <==>update test set age=age-1 where name='test01'


//排序查询
> db.test.find({},{_id:0,name:1,age:1}).sort({age:-1})  <==>select name,age from test order by age desc 
{ "name" : "test02", "age" : 32 }
{ "name" : "test01", "age" : 24 }


//查询数量
> db.test.find({age:{$gte:10}}).count();   <==>select count(*) from test where age>10
> db.test.count();  <==>select count(*) from test


//分页查询
> db.test.find().limit(2).skip(1);  <==>select * from test limit 1,2


//删除数据
> db.test.remove({name:null});  <==>delete from test where name=NULL 
> db.test.remove({name:'test01'});  <==>delete from test where name='test01'


//过滤数据
db.test.distinct('name',{'age':{$lt:20}}) <==> select distinct(name) from test where age<20

//数据分组
db.test.group({key:{'name':true},cond:{'name':'test01'},reduce:function(obj,prev){prev.msum+=obj.marks;},initial:{msum:0}}) <==> select name,sum(marks) from test where name='test01' group by name

 

七、MongoDB基本操作
db.AddUser(username,password) 添加用户
db.auth(usrename,password) 设置数据库连接验证
db.cloneDataBase(fromhost) 从目标服务器克隆一个数据库
db.commandHelp(name) returns the help for the command
db.copyDatabase(fromdb,todb,fromhost) 复制数据库fromdb---源数据库名称，todb---目标数据库名称，fromhost---源数据库服务器地址
db.createCollection(name,{size:3333,capped:333,max:88888}) 创建一个数据集，相当于一个表
db.currentOp() 取消当前库的当前操作
db.dropDataBase() 删除当前数据库
db.eval(func,args) run code server-side
db.getCollection(cname) 取得一个数据集合，同用法：db['cname'] or
db.getCollenctionNames() 取得所有数据集合的名称列表
db.getLastError() 返回最后一个错误的提示消息
db.getLastErrorObj() 返回最后一个错误的对象
db.getMongo() 取得当前服务器的连接对象get the server
db.getMondo().setSlaveOk() allow this connection to read from then nonmaster membr of a replica pair
db.getName() 返回当操作数据库的名称
db.getPrevError() 返回上一个错误对象
db.getProfilingLevel()
db.getReplicationInfo() 获得重复的数据
db.getSisterDB(name) get the db at the same server as this onew
db.killOp() 停止（杀死）在当前库的当前操作
db.printCollectionStats() 返回当前库的数据集状态
db.printReplicationInfo()
db.printSlaveReplicationInfo()
db.printShardingStatus() 返回当前数据库是否为共享数据库
db.removeUser(username) 删除用户
db.repairDatabase() 修复当前数据库
db.resetError()
db.runCommand(cmdObj) run a database command. if cmdObj is a string, turns it into {cmdObj:1}
db.setProfilingLevel(level) 0=off,1=slow,2=all
db.shutdownServer() 关闭当前服务程序
db.version() 返回当前程序的版本信息
　　数据集(表)操作
db.test.find({id:10}) 返回test数据集ID=10的数据集
db.test.find({id:10}).count() 返回test数据集ID=10的数据总数
db.test.find({id:10}).limit(2) 返回test数据集ID=10的数据集从第二条开始的数据集
db.test.find({id:10}).skip(8) 返回test数据集ID=10的数据集从0到第八条的数据集
db.test.find({id:10}).limit(2).skip(8) 返回test数据集ID=1=的数据集从第二条到第八条的数据
db.test.find({id:10}).sort() 返回test数据集ID=10的排序数据集
db.test.findOne([query]) 返回符合条件的一条数据
db.test.getDB() 返回此数据集所属的数据库名称
db.test.getIndexes() 返回些数据集的索引信息
db.test.group({key:...,initial:...,reduce:...[,cond:...]})
db.test.mapReduce(mayFunction,reduceFunction,<optional params>)
db.test.remove(query) 在数据集中删除一条数据
db.test.renameCollection(newName) 重命名些数据集名称
db.test.save(obj) 往数据集中插入一条数据
db.test.stats() 返回此数据集的状态
db.test.storageSize() 返回此数据集的存储大小
db.test.totalIndexSize() 返回此数据集的索引文件大小
db.test.totalSize() 返回些数据集的总大小
db.test.update(query,object[,upsert_bool]) 在此数据集中更新一条数据
db.test.validate() 验证此数据集
db.test.getShardVersion() 返回数据集共享版本号

备份MySQL数据库的命令
mysqldump -hhostname -uusername -ppassword databasename > backupfile.sql

备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。
mysqldump -–add-drop-table -uusername -ppassword databasename > backupfile.sql

直接将MySQL数据库压缩备份
mysqldump -hhostname -uusername -ppassword databasename | gzip > backupfile.sql.gz

备份MySQL数据库某个(些)表
mysqldump -hhostname -uusername -ppassword databasename specific_table1 specific_table2 > backupfile.sql

同时备份多个MySQL数据库
mysqldump -hhostname -uusername -ppassword –databases databasename1 databasename2 databasename3 > multibackupfile.sql

仅仅备份数据库结构
mysqldump –no-data –databases databasename1 databasename2 databasename3 > structurebackupfile.sql

备份服务器上所有数据库
mysqldump –all-databases > allbackupfile.sql

还原MySQL数据库的命令
mysql -hhostname -uusername -ppassword databasename < backupfile.sql

还原压缩的MySQL数据库
gunzip < backupfile.sql.gz | mysql -uusername -ppassword databasename

将数据库转移到新服务器
mysqldump -uusername -ppassword databasename | mysql –host=*.*.*.* -C databasename