[转]MySQL的LIMIT与分页优化

最近读高性能Mysql,一点简单的优化:
在系统中需要进行分页操作的时候,我们通常会使用LIMIT加上偏移量的办法实现,同时加上合适的ORDER BY子句。如果有对应的索引,通常效率会不错,否则,MySQL需要做大量的文件排序操作。

一个非常常见又令人头疼的问题就是,在偏移量非常大的时候,例如可能是LIMIT 10000,20这样的查询,这时MySQL需要查询10020条记录后只返回最后20条,前面10000条记录都将被抛弃,这样的代价非常高。如果所有的页面被访问的频率都相同,那么这样的查询平均需要访问半个表的数据。要优化这种查询,要么是在页面中限制分页的数量,要么是优化大偏移量的性能。

优化此类分页查询的一个最简单的办法就是尽可能地使用索引覆盖扫描,而不是查询所有的列。然后根据需要做一次关联操作再返回所需的列。对于偏移量很大的时候,这样的效率会提升非常大。考虑下面的查询:

SELECT film_id, description FROM sakila.film ORDER BY title LIMIT 50, 5;

如果这个表非常大,那么这个查询最好改写成下面的这样子:

SELECT film.film_id, film.description FROM sakila.film
INNER JOIN (
SELECT film_id FROM sakila.film ORDER BY title LIMIT 50,5
) AS lim USING(film_id);

这里的“延迟关联”将大大提升查询效率,它让MySQL扫描尽可能少的页面,获取需要访问的记录后再根据关联列回原表查询需要的所有列。这个技术也可以用于优化关联查询中的LIMIT子句。

有时候也可以将LIMIT查询转换为已知的位置的查询,让MySQL通过范围扫描获得到对应的结果。例如,如果在一个位置列上有索引,并且预先计算出了边界值,上面的查询就可以改写为:

SELECT film_id, description FROM sakila.film
WHERE position BETWEEN 50 AND 54 ORDER BY position;

对数据进行排名的问题也与此类似,但往往还会同时和GROUP BY混合使用。在这种情况下通常都需要预先计算并存储排名信息。

LIMIT和OFFSET的问题,其实是OFFSET的问题,它会导致MySQL扫描大量不需要的行然后再抛弃掉。如果可以使用书签记录上次取数据的位置,那么下次就可以直接从该书签记录的位置开始扫描,这样就可以避免使用OFFSET。例如,若需要按照租借记录做翻页,那么可以根据最新一条租借记录向后追溯,这种做法可行是因为租借记录的主键是单调增长的。首先使用下面的查询获得一组结果:

SELECT * FROM sakila.rental ORDER BY rental_id DESC LIMIT 20;

假设上面的查询返回的是主键为16049到16030的租借记录,那么下一页查询就可以从16030这个点开始:

SELECT * FROM sakila.rental WHERE rental_id < 16030 ORDER BY rental_id DESC LIMIT 20; 该技术的好处是无论翻页到那么后面,其性能都会很好。 其他优化办法还包括使用预先计算的汇总表,或者关联到一个冗余表,冗余表只包含主键列和需要做排序的数据列。 分页的时候,另一个常用的技巧是在LIMIT语句中加上SQL_CALC_FOUNT_ROWS提示(hint),这样就可以获得去掉LIMIT以后满足条件的行数,因此可以作为分页的总数。看起来,MySQL做了一些非常“高深”的优化,像是通过某种方法预测了总行数。但实际上,MySQL只有在扫描了所有满足条件的行以后,才会知道行数,所以加上这个提示以后,不管是否需要,MySQL都会扫描所有满足条件的行,然后再抛弃掉不需要的行,而不是在满足LIMIT的行数后就终止扫描。所以该提示的代价可能非常高。 一个更好的设计是将具体的页数换成“下一页”按钮,假设每页显示20条记录,那么我们每次查询的时候都是LIMIT返回21条记录并只显示20条,如果第21条存在,那么我们就显示“下一页”按钮,否则就说明没有更多的数据,也就无须显示“下一页”按钮了。 另一种做法是先获取并缓存较多的数据,例如,缓存1000条,然后每次分页都从这个缓存中获取。这样做可以让应用程序根据结果集的大小采取不同的策略,如果结果集少于1000,就可以在页面上显示所有的分页链接,因为数据都在缓存中,所以这样做性能不会有问题。如果结果集大于1000,则可以在页面上设计一个额外的“找到的结果多于1000条”之类的按钮。这两种策略都比每次生成全部结果集再抛弃掉不需要的数据的效率要高很多。 有时候也可以考虑使用EXPLAIN的结果中的rows列的值来作为结果集总数的近似值(实际上Google的搜索结果总数也是个近似值)。当需要精确结果的时候,再单独使用COUNT(*)来满足需求,这时如果能够使用索引覆盖扫描则通常也会比SQL_CALC_FOUND_ROWS快得多。

php-fpm进程数动静态优化方法

背景
最近将Wordpress迁移至阿里云。由于自己的服务器是云服务器,硬盘和内存都比较小,所以内存经常不够使,通过Linux命令查看后,发现启动php-fpm进程数有20多个,占用了将近1G的内存,整个服务器才1.5G的内存,最后通过对php-fpm进程数优化解决了此问题,服务器多节省出600M的内存,将php-fpm的优化方法和大家分享下。
备注:目前根据nginx、fpm-php进行了内存优化,详情见相关资料
php-fpm优化

1、php-fpm优化参数介绍
他们分别是:pm、pm.max_children、pm.start_servers、pm.min_spare_servers、pm.max_spare_servers。

pm:表示使用那种方式,有两个值可以选择,就是static(静态)或者dynamic(动态)。
在更老一些的版本中,dynamic被称作apache-like。这个要注意看配置文件的说明。

下面4个参数的意思分别为:

pm.max_children:静态方式下开启的php-fpm进程数量
pm.start_servers:动态方式下的起始php-fpm进程数量
pm.min_spare_servers:动态方式下的最小php-fpm进程数
pm.max_spare_servers:动态方式下的最大php-fpm进程数量

区别:

如果pm设置为 static,那么其实只有pm.max_children这个参数生效。系统会开启设置数量的php-fpm进程。
如果pm设置为 dynamic,那么pm.max_children参数失效,后面3个参数生效。
系统会在php-fpm运行开始 的时候启动pm.start_servers个php-fpm进程,
然后根据系统的需求动态在pm.min_spare_servers和pm.max_spare_servers之间调整php-fpm进程数

2、服务器具体配置
对于我们的服务器,选择哪种执行方式比较好呢?事实上,跟Apache一样,运行的PHP程序在执行完成后,或多或少会有内存泄露的问题。
这也是为什么开始的时候一个php-fpm进程只占用3M左右内存,运行一段时间后就会上升到20-30M的原因了。
对于内存大的服务器(比如8G以上)来说,指定静态的max_children实际上更为妥当,因为这样不需要进行额外的进程数目控制,会提高效率。
因为频繁开关php-fpm进程也会有时滞,所以内存够大的情况下开静态效果会更好。数量也可以根据 内存/30M 得到,比如8GB内存可以设置为100,
那么php-fpm耗费的内存就能控制在 2G-3G的样子。如果内存稍微小点,比如1G,那么指定静态的进程数量更加有利于服务器的稳定。
这样可以保证php-fpm只获取够用的内存,将不多的内存分配给其他应用去使用,会使系统的运行更加畅通。
对于小内存的服务器来说,比如256M内存的VPS,即使按照一个20M的内存量来算,10个php-cgi进程就将耗掉200M内存,那系统的崩溃就应该很正常了。
因此应该尽量地控制php-fpm进程的数量,大体明确其他应用占用的内存后,给它指定一个静态的小数量,会让系统更加平稳一些。或者使用动态方式,
因为动态方式会结束掉多余的进程,可以回收释放一些内存,所以推荐在内存较少的服务器或VPS上使用。具体最大数量根据 内存/20M 得到。
比如说512M的VPS,建议pm.max_spare_servers设置为20。至于pm.min_spare_servers,则建议根据服务器的负载情况来设置,比如服务器上只是部署php环境的话,比较合适的值在5~10之间。

[转]How do you build a database?

原文链接:https://www.reddit.com/r/Database/comments/27u6dy/how_do_you_build_a_database/ciggal8

Its a great question, and deserves a long answer.
Most database servers are built in C, and store data using B-tree type constructs. In the old days there was a product called C-Isam (c library for an indexed sequential access method) which is a low level library to help C programmers write data in B-tree format. So you need to know about btrees and understand what these are.
Most databases store data separate to indexes. Lets assume a record (or row) is 800 bytes long and you write 5 rows of data to a file. If the row contains columns such as first name, last name, address etc. and you want to search for a specific record by last name, you can open the file and sequentially search through each record but this is very slow. Instead you open an index file which just contains the lastname and the position of the record in the data file. Then when you have the position you open the data file, lseek to that position and read the data. Because index data is very small it is much quicker to search through index files. Also as the index files are stored in btrees in it very quick to effectively do a quicksearch (divide and conquer) to find the record you are looking for.
So you understand for one “table” you will have a data file with the data and one (or many) index files. The first index file could be for lastname, the next could be to search by SS number etc. When the user defines their query to get some data, they decide which index file to search through. If you can find any info on C-ISAM (there used to be an open source version (or cheap commercial) called D-ISAM) you will understand this concept quite well.
Once you have stored data and have index files, using an ISAM type approach allows you to GET a record based on a value, or PUT a new record. However modern database servers all support SQL, so you need an SQL parser that translates the SQL statement into a sequence of related GETs. SQL may join 2 tables so an optimizer is also needed to decide which table to read first (normally based on number of rows in each table and indexes available) and how to relate it to the next table. SQL can INSERT data so you need to parse that into PUT statements but it can also combine multiple INSERTS into transactions so you need a transaction manager to control this, and you will need transaction logs to store wip/completed transactions.
It is possible you will need some backup/restore commands to backup your data files and index files and maybe also your transaction log files, and if you really want to go for it you could write some replication tools to read your transaction log and replicate the transactions to a backup database on a different server. Note if you want your client programs (for example an SQL UI like phpmyadmin) to reside on separate machine than your database server you will need to write a connection manager that sends the SQL requests over TCP/IP to your server, then authenticate it using some credentials, parse the request, run your GETS and send back the data to the client.
So these database servers can be a lot of work, especially for one person. But you can create simple versions of these tools one at a time. Start with how to store data and indexes, and how to retrieve data using an ISAM type interface.
There are books out there – look for older books on mysql and msql, look for anything on google re btrees and isam, look for open source C libraries that already do isam. Get a good understanding on file IO on a linux machine using C. Many commercial databases now dont even use the filesystem for their data files because of cacheing issues – they write directly to raw disk. You want to just write to files initially.
I hope this helps a little bit.

[转] 【Shell】sed使用心得

原文链接:http://blog.itpub.net/519536/viewspace-558364/
sed 是一种UNIX/LINUX 平台下的轻量级流编辑器,日常一般用于处理文本文件。sed 有许多很好的特性。首先,它相当小巧;其次, sed 可以配合强大的 shell 完成许多复杂的功能。在我看来,sed完全可以看成一个脚本解释器,用类似于编程的手段完成许多事情。
sed简单示例
sed命令的格式是
sed [-options] [command] [stdin]
比如这个例子
$ sed –e ‘d’ ./Mydir/Myfile
执行该命令,将得不到任何输出。在该例中,用一个编辑命令 ‘d’ 调用 sed;sed 打开 ./Mydir/Myfile 将一行读入其模式缓冲区,执行’d’(“删除行”);然后打印模式缓冲区(缓冲区已为空);它对后面的每一行重复这些步骤,这不会产生输出!
对 这个命令要说明的几点是:首先,它根本没有修改 ./Mydir/Myfile。这是因为 sed 是流处理器,它只读取在命令行指定的文件,它不试图修改该文件。其次, sed 是面向行的,’d’ 命令不是简单地告诉 sed 一下子删除所有输入数据;相反,sed 逐行将 ./Mydir/Myfile 的每一行读入其称为模式缓冲区的内部缓冲区,一旦将一行读入模式缓冲区,它就执行 ‘d’ 命令,然后打印模式缓冲区的内容。最后要注意的事是括起 ‘d’ 命令的单引号的用法,这样可以禁用 shell 扩展。
指定sed的作用范围
看下面的三个例子
$ sed –e ‘1d’ ./Mydir/Myfile
$ sed –e ‘1,10d’ ./Mydir/Myfile
$ sed –e ‘/begin/,/end/p’ ./Mydir/Myfile
第一个例子说明只删除./Mydir/Myfile第一行的缓冲,第二个例子将删除第1~10行的缓冲。第三个例子最复杂,它定义了以字符串’begin’开始到’end’结束的作用范围
sed中的正则表达式
sed支持正则表达式,比如
$ sed –n -e ‘/regexp/p’ ./Mydir/Myfile
比如要删除所有的空行
$ sed –e ‘/^$/d’ ./Mydir/Myfile
sed中的一些特殊定义是
规则 表达式 描述
/./ 将与包含至少一个字符的任何行匹配
/../ 将与包含至少两个字符的任何行匹配
/^#/ 将与以 ‘#’ 开始的任何行匹配
/^$/ 将与所有空行匹配
/}^/ 将与以 ‘}’(无空格)结束的任何行匹配
/} *^/ 将与以 ‘}’ 后面跟有 零或多个空格结束的任何行匹配
/[abc]/ 将与包含小写 ‘a’、’b’ 或 ‘c’ 的任何行匹配
/^[abc]/ 将与以 ‘a’、’b’ 或 ‘c’ 开始的任何行匹配
再比如一个经典的例子,打印c源代码中的main函数内容,其命令可以写成如下
$ sed –n –e ‘/main[[:space]]*(/,/^}/p’ ./Mydir/*.c
其中[:space]表示空格,[[:space]]*表示有0~多个空格,所以main[[:space]]*(的意思是匹配“main (”字符串;“^}”表示这一行有且只有一个字符}。当然,上面的命令不是十分严谨。
sed –e ‘s/regexp/repalcement’ file
替换是sed命令中最常用的命令,比如如下的例子
$ sed –e ‘s/a/b’ ./Mydir/Myfile
$ sed –e ‘s/a/b/g’ ./Mydir/Myfile
第一个命令将./Mydir/Myfile中每一行第一次出现的字符a替换成字符b;第二个命令由于加入了’/g’,表示是全局(全部)替换字符a成字符b。
经常还可以看见如下两种形式的sed
$ sed –e ‘1,10s/a/b’ ./Mydir/Myfile
$ sed –e ‘/^$/,/^END/s/a/b/g’ ./Mydir/Myfile
第一个命令是指替换1~10行;第二个命令是指全局替换从空行开始到以END开始的行中的内容。
替换命令不一定非要以/分隔,比如
$ sed –e ‘s:usr/local:/usr:g’ ./Mydir/Myfile
就是将./Mydir/Myfile中的usr/local全部替换成/usr
要用好替换命令,当然要使用正则表达式,除了上面所说的表达式的例子,还有一些是非常有用的
字符类 描述
[:alnum:] 字母数字 [a-z A-Z 0-9]
[:alpha:] 字母 [a-z A-Z]
[:blank:] 空格或制表键
[:cntrl:] 任何控制字符
[:digit:] 数字 [0-9]
[:graph:] 任何可视字符(无空格)
[:lower:] 小写 [a-z]
[:print:] 非控制字符
[:punct:] 标点字符
[:space:] 空格
[:upper:] 大写 [A-Z]
[:xdigit:] 十六进制数字 [0-9 a-f A-F]
比如下面这个例子
$ sed –e ‘s/<[^>]*>//g’ ./Mydir/Myfile
< [^>]*>匹配<…>这样的字符串(…中不含>)。运行这个命令,能够将 “This is what I meant.”这样的字符串替换成“This is what I meant.”
考察如下的命令
$ sed -e ‘s/.*/# &/’ ./Mydir/Myfile
这个命令将所有的非空行以“#”注释掉——&告诉sed在行首插入字符。
‘s///’允许我们在规则表达式中定义区域,然后可以在替换字符串中引用这些特定区域。这些区域是以(和)隔开的。
比如定义三个匹配非空字符的区域'(.*) (.*) (.*)’,现在可以定义这三个区域的动作,比如
$ sed -e ‘s/(.*) (.*) (.*)/PreFix 1-2 Fix 3/’ ./Mydir/Myfile
假如把三个区域分别命名为a、b、c,则最后结果是 PreFix a-b Fix c
sed中组合命令
sed中的命令可以组合,以;号隔开,比如
$ sed –n –e ‘=;p’ ./Mydir/Myfile
=表示打印行号,p表示打印。对于更复杂的指令,则可以写成命令脚本,然后用-f选项导入,比如
$ sed –n –f MyScript.sed ./Mydir/Myfile
对于同一个地址上的操作,则可以用{}组合,比如
$ sed –n ‘1,20{ s/samba/Samba/g s/posix/POSIX/g }’ ./Mydir/Myfile
sed中的行附加命令
在当前行之前插入行“i”,如果要插入多行,则将多行用分隔
在当前行之后插入行“a”,用法和上面相似
更改当前行“c”

[转] 关于分布式事务、两阶段提交协议、三阶提交协议

原文链接:http://blog.jobbole.com/95632/
3PC
三阶段提交(Three-phase commit),也叫三阶段提交协议(Three-phase commit protocol),是二阶段提交(2PC)的改进版本。

与两阶段提交不同的是,三阶段提交有两个改动点。
1、引入超时机制。同时在协调者和参与者中都引入超时机制。
2、在第一阶段和第二阶段中插入一个准备阶段。保证了在最后提交阶段之前各参与节点的状态是一致的。
也就是说,除了引入超时机制之外,3PC把2PC的准备阶段再次一分为二,这样三阶段提交就有CanCommit、PreCommit、DoCommit三个阶段。
CanCommit阶段
3PC的CanCommit阶段其实和2PC的准备阶段很像。协调者向参与者发送commit请求,参与者如果可以提交就返回Yes响应,否则返回No响应。
1.事务询问 协调者向参与者发送CanCommit请求。询问是否可以执行事务提交操作。然后开始等待参与者的响应。
2.响应反馈 参与者接到CanCommit请求之后,正常情况下,如果其自身认为可以顺利执行事务,则返回Yes响应,并进入预备状态。否则反馈No
PreCommit阶段
协调者根据参与者的反应情况来决定是否可以记性事务的PreCommit操作。根据响应情况,有以下两种可能。
假如协调者从所有的参与者获得的反馈都是Yes响应,那么就会执行事务的预执行。
1.发送预提交请求 协调者向参与者发送PreCommit请求,并进入Prepared阶段。
2.事务预提交 参与者接收到PreCommit请求后,会执行事务操作,并将undo和redo信息记录到事务日志中。
3.响应反馈 如果参与者成功的执行了事务操作,则返回ACK响应,同时开始等待最终指令。
假如有任何一个参与者向协调者发送了No响应,或者等待超时之后,协调者都没有接到参与者的响应,那么就执行事务的中断。
1.发送中断请求 协调者向所有参与者发送abort请求。
2.中断事务 参与者收到来自协调者的abort请求之后(或超时之后,仍未收到协调者的请求),执行事务的中断。
doCommit阶段
该阶段进行真正的事务提交,也可以分为以下两种情况。
执行提交
1.发送提交请求 协调接收到参与者发送的ACK响应,那么他将从预提交状态进入到提交状态。并向所有参与者发送doCommit请求。
2.事务提交 参与者接收到doCommit请求之后,执行正式的事务提交。并在完成事务提交之后释放所有事务资源。
3.响应反馈 事务提交完之后,向协调者发送Ack响应。
4.完成事务 协调者接收到所有参与者的ack响应之后,完成事务。
中断事务 协调者没有接收到参与者发送的ACK响应(可能是接受者发送的不是ACK响应,也可能响应超时),那么就会执行中断事务。
1.发送中断请求 协调者向所有参与者发送abort请求
2.事务回滚 参与者接收到abort请求之后,利用其在阶段二记录的undo信息来执行事务的回滚操作,并在完成回滚之后释放所有的事务资源。
3.反馈结果 参与者完成事务回滚之后,向协调者发送ACK消息
4.中断事务 协调者接收到参与者反馈的ACK消息之后,执行事务的中断。
`在doCommit阶段,如果参与者无法及时接收到来自协调者的doCommit或者rebort请求时,会在等待超时之后,会继续进行事务的提交。(其实这个应该是基于概率来决定的,当进入第三阶段时,说明参与者在第二阶段已经收到了PreCommit请求,那么协调者产生PreCommit请求的前提条件是他在第二阶段开始之前,收到所有参与者的CanCommit响应都是Yes。(一旦参与者收到了PreCommit,意味他知道大家其实都同意修改了)所以,一句话概括就是,当进入第三阶段时,由于网络超时等原因,虽然参与者没有收到commit或者abort响应,但是他有理由相信:成功提交的几率很大。 )`
2PC与3PC的区别
相对于2PC,3PC主要解决的单点故障问题,并减少阻塞,因为一旦参与者无法及时收到来自协调者的信息之后,他会默认执行commit。而不会一直持有事务资源并处于阻塞状态。但是这种机制也会导致数据一致性问题,因为,由于网络原因,协调者发送的abort响应没有及时被参与者接收到,那么参与者在等待超时之后执行了commit操作。这样就和其他接到abort命令并执行回滚的参与者之间存在数据不一致的情况。
________________________________________
了解了2PC和3PC之后,我们可以发现,无论是二阶段提交还是三阶段提交都无法彻底解决分布式的一致性问题。Google Chubby的作者Mike Burrows说过, there is only one consensus protocol, and that’s Paxos” – all other approaches are just broken versions of Paxos. 意即世上只有一种一致性算法,那就是Paxos,所有其他一致性算法都是Paxos算法的不完整版。后面的文章会介绍这个公认为难于理解但是行之有效的Paxos算法。

[转]mysql 联合索引详解

【原文链接】http://blog.csdn.net/lmh12506/article/details/8879916
联合索引又叫复合索引。对于复合索引:Mysql从左到右的使用索引中的字段,一个查询可以只使用索引中的一部份,但只能是最左侧部分。例如索引是key index (a,b,c). 可以支持a | a,b| a,b,c 3种组合进行查找,但不支持 b,c进行查找 .当最左侧字段是常量引用时,索引就十分有效。

两个或更多个列上的索引被称作复合索引。
利用索引中的附加列,您可以缩小搜索的范围,但使用一个具有两列的索引 不同于使用两个单独的索引。复合索引的结构与电话簿类似,人名由姓和名构成,电话簿首先按姓氏对进行排序,然后按名字对有相同姓氏的人进行排序。如果您知 道姓,电话簿将非常有用;如果您知道姓和名,电话簿则更为有用,但如果您只知道名不姓,电话簿将没有用处。
所以说创建复合索引时,应该仔细考虑列的顺序。对索引中的所有列执行搜索或仅对前几列执行搜索时,复合索引非常有用;仅对后面的任意列执行搜索时,复合索引则没有用处。
如:建立 姓名、年龄、性别的复合索引。

create table test(
a int,
b int,
c int,
KEY a(a,b,c)
);

优: select * from test where a=10 and b>50
差: select * from test where a50

优: select * from test order by a
差: select * from test order by b
差: select * from test order by c

优: select * from test where a=10 order by a
优: select * from test where a=10 order by b
差: select * from test where a=10 order by c

优: select * from test where a>10 order by a
差: select * from test where a>10 order by b
差: select * from test where a>10 order by c

优: select * from test where a=10 and b=10 order by a
优: select * from test where a=10 and b=10 order by b
优: select * from test where a=10 and b=10 order by c

优: select * from test where a=10 and b=10 order by a
优: select * from test where a=10 and b>10 order by b
差: select * from test where a=10 and b>10 order by c

mysql 复合索引,联合索引 – flyflying1987 – ly

索引原则

1.索引越少越好
原因:主要在修改数据时,第个索引都要进行更新,降低写速度。
2.最窄的字段放在键的左边
3.避免file sort排序,临时表和表扫描.

centos mongodb的安装和使用

1、下载MongoDB(64位)
http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.4.9.tgz
2、安装MongoDB(安装到/usr/local)

tar zxvf mongodb-linux-x86_64-2.4.9.tgz
mv mongodb-linux-x86_64-2.4.9 mongodb
cd mongodb
mkdir db
mkdir logs
cd bin
vi mongodb.conf

dbpath=/usr/local/mongodb/db
logpath=/usr/local/mongodb/logs/mongodb.log
port=27017
fork=true
nohttpinterface=true

3、重新绑定mongodb的配置文件地址和访问IP
/usr/local/mongodb/bin/mongod –smallfiles –bind_ip localhost -f /usr/local/mongodb/bin/mongodb.conf

4、开机自动启动mongodb
vi /etc/rc.d/rc.local
/usr/local/mongodb/bin/mongod –config /usr/local/mongodb/bin/mongodb.conf

5、重启一下系统测试下能不能自启
#进入mongodb的shell模式
/usr/local/mongodb/bin/mongo
#查看数据库列表
show dbs
#当前db版本
db.version();

导入一批数据到mongodb,文件格式是csv

cat input.csv|while read line
do     
    echo $line | awk -F ';' -v OFS='' \
    '{print "db.mydb.insert({\"id\":"$1",\"user\":"$2",\"favorite_condition\":"$6"})"}' | mongo;
done

简单的查询:
db.mydb.find({“favorite_condition” : “1211046425881”}).count();

Mysql安装解决中文问号?乱码问题

第一、安装mysql之后默认的字符编码为latin1
登录mysql之后可以通过 show variables like ‘%char%’查看,显示如下
+———————-+—–--————–
| Variable_name | Value
+———————–+---——————
| character_set_client | latin1
| character_set_connection | latin1
| character_set_database | latin1
| character_set_filesystem | binary
| character_set_results | latin1
| character_set_server | latin1
| character_set_system | utf8
| character_sets_dir | /usr/share/mysql/charsets/
+———————+---——————-
第二、编辑/etc/my.cnf
在最后添加:
[client]
default-character-set=utf8
[mysqld_safe]
default-character-set=utf8
[mysqld]
default-character-set=utf8
[mysql]
default-character-set=utf8
保存退出。
第三、重启mysql服务
[root@linuxidc mysql]#service mysqld restart
第四、登录mysql之后 再次通过show variables like ‘%char%’查看,显示如下
+————————–+—————————-+
| Variable_name | Value |
+————————–+—————————-+
| character_set_client | utf8 |
| character_set_connection | utf8 |
| character_set_database | latin1 |
| character_set_filesystem | binary |
| character_set_results | utf8 |
| character_set_server | utf8 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+————————–+—————————-+