静室

将matplotlib画的图拷贝到剪贴板

2011-11-15T18:06:00.002+08:00

matplotlib画完的图没有copy的功能，于是组合了网上找到的几个函数，执行之后将figure中的图复制到剪贴板。


import matplotlib.pyplot as plt
from cStringIO import StringIO
import win32clipboard
from PIL import Image


def send_to_clipboard(clip_type, data):
    win32clipboard.OpenClipboard()
    win32clipboard.EmptyClipboard()
    win32clipboard.SetClipboardData(clip_type, data)
    win32clipboard.CloseClipboard()

def save_figure(f, file, w, h):
    if not f:
        f = plt.gcf()
    dpi = f.get_dpi()
    f.set_figwidth(w / dpi)
    f.set_figheight(h /dpi)
    f.savefig(file)

def copy_figure(w=600, h=400, fig=None):
    file = StringIO()
    save_figure(fig, file, w, h)
    file.seek(0)
    image = Image.open(file)
    output = StringIO()
    image.convert("RGB").save(output, "BMP")
    data = output.getvalue()[14:]
    output.close()
    send_to_clipboard(win32clipboard.CF_DIB, data)

服务器进程卡死调查

2011-09-22T18:43:00.003+08:00

服务器上运行了一个python的爬虫程序，一直运行的很好的。今天凌晨突然进程占cpu 100%，然后爬取一直无法继续，因为是多线程的，用strace, ltrace都只能看到线程在等待锁。后来想到用gdb查看线程的信息，gdb完全不会用，只好借用poor man's profiler里的

(echo "set pagination 0";
echo "thread apply all bt";
echo "quit"; cat /dev/zero ) | gdb -p [processid]

得到

Thread 12 (Thread 0x41d61940 (LWP 2741)):
#0  0x000000333120cb21 in sem_wait () from /lib64/libpthread.so.0
#1  0x00000000004c06ad in PyThread_acquire_lock (lock=0x48bb110, waitflag=1) at Python/thread_pthread.h:349
#2  0x000000000048c6fa in PyEval_AcquireThread (tstate=0x48e8a10) at Python/ceval.c:253
#3  0x00002b31ff3b9121 in util_write_callback ...
#4  0x00002b31ff5d9bf8 in Curl_client_write ...
#5  0x00002b31ff5f030f in Curl_httpchunk_read ...
#6  0x00002b31ff5ee150 in readwrite_data (conn=0x2aaaac052b70, done=0x41d606c7) at transfer.c:530
#7  Curl_readwrite (conn=0x2aaaac052b70, done=0x41d606c7) at transfer.c:1600
#8  0x00002b31ff5ef016 in Transfer (data=0x2aaaac053b10) at transfer.c:1855
#9  Curl_perform (data=0x2aaaac053b10) at transfer.c:2451
#10 0x00002b31ff3b9503 in do_curl_perform (self=0x2aaaac047120) at src/pycurl.c:1024
#11 0x0000000000492f12 in call_function (f=0x4a70930, throwflag=) at Python/ceval.c:3690
#12 PyEval_EvalFrameEx (f=0x4a70930, throwflag=) at Python/ceval.c:2389
#13 0x0000000000494b7d in PyEval_EvalCodeEx (co=0x484ddc8, globals=, locals=, args=0x4a706a8, argcount=1, kws=0x4a706b0, kwcount=0, defs=0x0, defcount=0, closure=0x0) at Python/ceval.c:2968
#14 0x0000000000492d71 in call_function (f=0x4a70510, throwflag=) at Python/ceval.c:3802
#15 PyEval_EvalFrameEx (f=0x4a70510, throwflag=) at Python/ceval.c:2389
#16 0x00000000004941c5 in call_function (f=0x4a70340, throwflag=) at Python/ceval.c:3792
#17 PyEval_EvalFrameEx (f=0x4a70340, throwflag=) at Python/ceval.c:2389
#18 0x0000000000494b7d in PyEval_EvalCodeEx (co=0x475e6c0, globals=, locals=, args=0x4a12ee8, argcount=1, kws=0x0, kwcount=0, defs=0x0, defcount=0, closure=0x0) at Python/ceval.c:2968
#19 0x00000000004ea69d in function_call (func=0x4799cf8, arg=0x4a12ed0, kw=0x0) at Objects/funcobject.c:524
#20 0x0000000000417bbd in PyObject_Call (func=0x4799cf8, arg=0x4a12ed0, kw=0x0) at Objects/abstract.c:2492
#21 0x000000000041efcf in instancemethod_call (func=, arg=0x4a12ed0, kw=0x0) at Objects/classobject.c:2579
#22 0x0000000000417bbd in PyObject_Call (func=0x4858b40, arg=0x2b31f944d050, kw=0x0) at Objects/abstract.c:2492
#23 0x000000000048c516 in PyEval_CallObjectWithKeywords (func=0x4858b40, arg=0x2b31f944d050, kw=0x0) at Python/ceval.c:3575
#24 0x00000000004c39ad in t_bootstrap (boot_raw=0x4a63920) at ./Modules/threadmodule.c:425
#25 0x0000003331206617 in start_thread () from /lib64/libpthread.so.0
#26 0x0000003330ad3c2d in clone () from /lib64/libc.so.6

Thread 11 (Thread 0x427f5940 (LWP 2742)):
#0  0x000000333120cb21 in sem_wait () from /lib64/libpthread.so.0
#1  0x00000000004c06ad in PyThread_acquire_lock (lock=0x48bb110, waitflag=1) at Python/thread_pthread.h:349
#2  0x000000000048c6fa in PyEval_AcquireThread (tstate=0x48e18e0) at Python/ceval.c:253
#3  0x00002b31ff3b9121 in util_write_callback ...
#4  0x00002b31ff5d9bf8 in Curl_client_write ...
#5  0x00002b31ff5f030f in Curl_httpchunk_read ...
#6  0x00002b31ff5ee150 in readwrite_data (conn=0x2aaaac001170, done=0x427f46c7) at transfer.c:530
#7  Curl_readwrite (conn=0x2aaaac001170, done=0x427f46c7) at transfer.c:1600
#8  0x00002b31ff5ef016 in Transfer (data=0x2aaaac086660) at transfer.c:1855
#9  Curl_perform (data=0x2aaaac086660) at transfer.c:2451
#10 0x00002b31ff3b9503 in do_curl_perform (self=0x2aaaac048430) at src/pycurl.c:1024
#11 0x0000000000492f12 in call_function (f=0x4a72760, throwflag=) at Python/ceval.c:3690
#12 PyEval_EvalFrameEx (f=0x4a72760, throwflag=) at Python/ceval.c:2389
#13 0x0000000000494b7d in PyEval_EvalCodeEx (co=0x484ddc8, globals=, locals=, args=0x4a71cb8, argcount=1, kws=0x4a71cc0, kwcount=0, defs=0x0, defcount=0, closure=0x0) at Python/ceval.c:2968
#14 0x0000000000492d71 in call_function (f=0x4a71b20, throwflag=) at Python/ceval.c:3802
#15 PyEval_EvalFrameEx (f=0x4a71b20, throwflag=) at Python/ceval.c:2389
#16 0x00000000004941c5 in call_function (f=0x4a71950, throwflag=) at Python/ceval.c:3792
#17 PyEval_EvalFrameEx (f=0x4a71950, throwflag=) at Python/ceval.c:2389
#18 0x0000000000494b7d in PyEval_EvalCodeEx (co=0x475e6c0, globals=, locals=, args=0x4a2aea8, argcount=1, kws=0x0, kwcount=0, defs=0x0, defcount=0, closure=0x0) at Python/ceval.c:2968
#19 0x00000000004ea69d in function_call (func=0x4799cf8, arg=0x4a2ae90, kw=0x0) at Objects/funcobject.c:524
#20 0x0000000000417bbd in PyObject_Call (func=0x4799cf8, arg=0x4a2ae90, kw=0x0) at Objects/abstract.c:2492
#21 0x000000000041efcf in instancemethod_call (func=, arg=0x4a2ae90, kw=0x0) at Objects/classobject.c:2579
#22 0x0000000000417bbd in PyObject_Call (func=0x4858d20, arg=0x2b31f944d050, kw=0x0) at Objects/abstract.c:2492
#23 0x000000000048c516 in PyEval_CallObjectWithKeywords (func=0x4858d20, arg=0x2b31f944d050, kw=0x0) at Python/ceval.c:3575
#24 0x00000000004c39ad in t_bootstrap (boot_raw=0x49a2ba0) at ./Modules/threadmodule.c:425
#25 0x0000003331206617 in start_thread () from /lib64/libpthread.so.0
#26 0x0000003330ad3c2d in clone () from /lib64/libc.so.6

Thread 6 (Thread 0x459fa940 (LWP 2747)):
#0  sre_match (state=0x459f8880, pattern=0x0) at ./Modules/_sre.c:1137
#1  0x00000000004d2a13 in sre_search (state=0x459f8880, pattern=0x4c8f4ba) at ./Modules/_sre.c:1609
#2  0x00000000004d3fc3 in pattern_findall (self=0x4c8f350, args=, kw=) at ./Modules/_sre.c:2072
#3  0x0000000000493261 in call_function (f=0x4868950, throwflag=) at Python/ceval.c:3706
#4  PyEval_EvalFrameEx (f=0x4868950, throwflag=) at Python/ceval.c:2389
#5  0x0000000000494b7d in PyEval_EvalCodeEx (co=0x490a198, globals=, locals=, args=0x4d8a410, argcount=2, kws=0x4d8a420, kwcount=0, defs=0x0, defcount=0, closure=0x0) at Python/ceval.c:2968
#6  0x0000000000492d71 in call_function (f=0x4d8a280, throwflag=) at Python/ceval.c:3802
#7  PyEval_EvalFrameEx (f=0x4d8a280, throwflag=) at Python/ceval.c:2389
#8  0x0000000000494b7d in PyEval_EvalCodeEx (co=0x4aff738, globals=, locals=, args=0x49fe318, argcount=1, kws=0x49fe320, kwcount=0, defs=0x0, defcount=0, closure=0x0) at Python/ceval.c:2968
#9  0x0000000000492d71 in call_function (f=0x49fe170, throwflag=) at Python/ceval.c:3802
#10 PyEval_EvalFrameEx (f=0x49fe170, throwflag=) at Python/ceval.c:2389
#11 0x0000000000494b7d in PyEval_EvalCodeEx (co=0x4852dc8, globals=, locals=, args=0x4a78380, argcount=3, kws=0x4a78398, kwcount=0, defs=0x0, defcount=0, closure=0x0) at Python/ceval.c:2968
#12 0x0000000000492d71 in call_function (f=0x4a781a0, throwflag=) at Python/ceval.c:3802
#13 PyEval_EvalFrameEx (f=0x4a781a0, throwflag=) at Python/ceval.c:2389
#14 0x0000000000494b7d in PyEval_EvalCodeEx (co=0x484ddc8, globals=, locals=, args=0x4a77818, argcount=1, kws=0x4a77820, kwcount=0, defs=0x0, defcount=0, closure=0x0) at Python/ceval.c:2968
#15 0x0000000000492d71 in call_function (f=0x4a77680, throwflag=) at Python/ceval.c:3802
#16 PyEval_EvalFrameEx (f=0x4a77680, throwflag=) at Python/ceval.c:2389
#17 0x00000000004941c5 in call_function (f=0x4a774b0, throwflag=) at Python/ceval.c:3792
#18 PyEval_EvalFrameEx (f=0x4a774b0, throwflag=) at Python/ceval.c:2389
#19 0x0000000000494b7d in PyEval_EvalCodeEx (co=0x475e6c0, globals=, locals=, args=0x4a318e8, argcount=1, kws=0x0, kwcount=0, defs=0x0, defcount=0, closure=0x0) at Python/ceval.c:2968
#20 0x00000000004ea69d in function_call (func=0x4799cf8, arg=0x4a318d0, kw=0x0) at Objects/funcobject.c:524
#21 0x0000000000417bbd in PyObject_Call (func=0x4799cf8, arg=0x4a318d0, kw=0x0) at Objects/abstract.c:2492
#22 0x000000000041efcf in instancemethod_call (func=, arg=0x4a318d0, kw=0x0) at Objects/classobject.c:2579
#23 0x0000000000417bbd in PyObject_Call (func=0x48fbe10, arg=0x2b31f944d050, kw=0x0) at Objects/abstract.c:2492
#24 0x000000000048c516 in PyEval_CallObjectWithKeywords (func=0x48fbe10, arg=0x2b31f944d050, kw=0x0) at Python/ceval.c:3575
#25 0x00000000004c39ad in t_bootstrap (boot_raw=0x49efb60) at ./Modules/threadmodule.c:425
#26 0x0000003331206617 in start_thread () from /lib64/libpthread.so.0
#27 0x0000003330ad3c2d in clone () from /lib64/libc.so.6

...

 Inferior 1 [process 2724] will be detached.

Quit anyway? (y or n) [answered Y; input not from terminal]
Detaching from program: /usr/local/python/bin/python2.6, process 2724

可以看到大部分的线程都在等待信号，只有一个线程是sre_search，这就是罪魁祸首了。具体的原因是正则匹配里有一个类似"a.*?b.*?c.*?d"的东西，页面今天改版之后，无法匹配，而这个表达式会不停的尝试，所以cpu一直是100%，这个线程也导致整个python进程卡死。

ie无法设置cookie的问题

2011-07-29T13:03:00.000+08:00

在测试站点上写cookie发现ie始终不会保存，其他浏览器都是好的。改各种东西测试了半天，最后发现是域名的问题，换了个域名问题就解决了。搞不清到底是什么毛病。

dns奇怪的问题

2011-05-25T15:21:00.001+08:00

公司里在ubuntu上架了bind服务，今天发现某些机器对某些地址进行dns解析时，返回NXDOMAIN，而同样的地址在另一些机器上又是可以正常解析的，它们用的dns都是自己架的这个。通过google和测试发现关闭dns服务器上的ipv6就都正常了。

在ubuntu上禁用ipv6：
注释掉 /etc/modprobe.d/aliases中的alias net-pf-10 ipv6，
然后在/etc/modprobe.d/blacklist中加入blacklist ipv6，
最后重启服务器。

虚拟机无法正常启动的问题

2011-03-16T16:13:00.002+08:00

在centos 5.5上用kvm再装centos，运行一段时间后重启会报错：

SELinux:  Disabled at runtime.
type=1404 audit(1299831154.138:2): selinux=0 auid=4294967295 ses=4294967295
INIT: version 2.86 booting
rc.sysinit[395]: segfault at 000000000f86a002 rip 000000000f86a002 rsp 00007fff2932cfc8 error 14
INIT: Entering runlevel: 3
rc[397]: segfault at 000000000f86a002 rip 000000000f86a002 rsp 00007fff2854c3d8 error 14

然后虚拟机占cpu一直是100%，也无法登陆。经测试发现，如果映像文件使用稀疏文件，那么运行几个小时之后重启就有这个问题，用普通文件没事。为什么就不知道了。

全屏切换后status bar导致屏幕下移

2010-12-14T15:26:00.001+08:00

当全屏切换出去之后再返回，status bar的位置会被空出来，导致整个view下移。
已经有人提了bug。
http://code.google.com/p/android/issues/detail?id=8052

下面的讨论中提供了一个hack，就是加上下面setFlags这句
http://groups.google.com/group/android-developers/browse_thread/thread/2de77043f32835aa/315d393bb8334db5


getWindow().setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);

组合WebView和ProgressBar

2010-12-11T02:04:00.003+08:00

想给WebView加一个进度条，结果发现android的文档中“Building Custom Components”提到的R.styleable这个类已经不能用了。我不想加xml配置，还没有找到什么好方法能处理初始化时的attrs。进度条在顶部固定显示在试了半天之后倒是弄好了。


@SuppressWarnings("deprecation")
public class ProgressWebView extends WebView {

   private ProgressBar progressbar;

   public ProgressWebView(Context context, AttributeSet attrs) {
       super(context, attrs);
       progressbar = new ProgressBar(context, null, android.R.attr.progressBarStyleHorizontal);
       progressbar.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT, 3, 0, 0));
       addView(progressbar);
       setWebViewClient(new WebViewClient());
       setWebChromeClient(new WebChromeClient());
   }

   public class WebChromeClient extends android.webkit.WebChromeClient {
       @Override
       public void onProgressChanged(WebView view, int newProgress) {
           if(newProgress == 100) {
               progressbar.setVisibility(GONE);
           } else {
               if(progressbar.getVisibility() == GONE)
                   progressbar.setVisibility(VISIBLE);
               progressbar.setProgress(newProgress);
           }
           super.onProgressChanged(view, newProgress);
       }
   }
 
   @Override
   protected void onScrollChanged(int l, int t, int oldl, int oldt) {
       LayoutParams lp = (LayoutParams) progressbar.getLayoutParams();
       lp.x = l;
       lp.y = t;
       progressbar.setLayoutParams(lp);
       super.onScrollChanged(l, t, oldl, oldt);
   }
}

emeditor的monokai配色

2010-04-16T10:51:00.004+08:00

看到textmate上的monokai配色，觉得很漂亮，移植到emeditor上了。因为最近基本只写python的代码，所以只有python的。

python.esy


; EmEditor Syntax File
;
; To import this file to an existing configuration, select Configuration
; under the Tool menu, select Define Configurations, select a configuration
; you want to import to, press [Properties], select the Highlight page, and
; press [Import].
;
; Submit your customized file to submit@emurasoft.com
; to be listed in www.emurasoft.com user files pages.
;
#Highlight=on
#BeginTag=
#EndTag=
#CommentBegin="""
#CommentEnd="""
#LineComment1=^#
#LineComment2=
#SingleQuote=on
#DoubleQuote=on
#ContinueQuote=off
#Escape=\
#ScriptBegin=
#ScriptEnd=
#SpecialSyntax=off
#HighlightBraces=on

#Keyword color=4,word=on,rightall=off,case=on,insidetag=off,regexp=off,rightall2=off
and
assert
break
continue
def
del
elif
else
except
exec
finally
for
from
global
if
import
in
is
lambda
not
or
pass
print
raise
return
try
while
as
with

#Keyword color=1,word=on,rightall=off,case=on,insidetag=off,regexp=off,rightall2=off
class
object
Exception
BaseException
StandardError
ArithmeticError
LookupError
EnvironmentError
AssertionError
AttributeError
EOFError
FloatingPointError
GeneratorExit
IOError
ImportError
IndexError
KeyError
KeyboardInterrupt
MemoryError
NameError
NotImplementedError
OSError
OverflowError
ReferenceError
RuntimeError
StopIteration
SyntaxError
SystemError
SystemExit
TypeError
UnboundLocalError
UnicodeError
UnicodeEncodeError
UnicodeDecodeError
UnicodeTranslateError
ValueError
VMSError
WindowsError
ZeroDivisionError
Warning
UserWarning
DeprecationWarning
PendingDeprecationWarning
SyntaxWarning
RuntimeWarning
FutureWarning
ImportWarning
UnicodeWarning
xrange
range
iter
sorted

#Keyword color=1,word=on,rightall=off,case=on,insidetag=off,regexp=on,rightall2=off
(?<!\.)list
(?<!\.)tuple
(?<!\.)dict
(?<!\.)set
(?<!\.)len
(?<!\.)all
(?<!\.)any
__(abs|add|and|class|cmp|coerce|delattr|div|divmod|doc)__
__(float|floordiv|format|getattribute|getnewargs|hash|hex|index)__
__(init|int|invert|long|lshift|mod|mul|neg|new|nonzero|oct|or|pos|pow)__
__(radd|rand|rdiv|rdivmod|reduce|reduceex|repr|rfloordiv|rlshift|rmod)__
__(rmul|ror|rpow|rrshift|rshift|rsub|rtruediv)__
__(rxor|setattr|sizeof|str|sub|subcl)__

#Keyword color=3,word=on,rightall=off,case=on,insidetag=off,regexp=off,rightall2=off
True
False
None

#Keyword color=2,word=on,rightall=off,case=on,insidetag=off,regexp=on,rightall2=off
\+|\=|\-|\*|\/|\!|\||\&|\^^|\@

#Keyword color=7,word=off,rightall=off,case=off,insidetag=off,regexp=on,rightall2=off
(?<=def )\w+(?=\(| \()

#Keyword color=3,word=on,rightall=off,case=off,insidetag=off,regexp=on,rightall2=off
[\-\+]?(\d+|\d+\.\d*|\.\d+)

monokai.eetheme


[Monokai]
MaxFind=1
Normal=#f8f8f2,#272822,normal
Sel=transparent,#49483e,normal
CurrentLine=transparent,#3e3d32,normal
Quoted=#c0c0ff,transparent,normal
Find=transparent,#40ff40,normal
URL=#008080,transparent,underline
Mail=#008000,transparent,underline
Tag=#808000,transparent,underline
SingleQuotes=#e6db74,transparent,normal
DoubleQuotes=#e6db74,transparent,normal
Comment=#75715e,transparent,normal
Script=#a6e22e,transparent,normal
Braces=#ffff00,transparent,bold
InTag=#a6e22e,transparent,normal
Highlight1=#66d9ef,transparent,normal
Highlight2=#fd971f,transparent,normal
Highlight3=#ae81ff,transparent,normal
Highlight4=#f92672,transparent,normal
Highlight5=#f8f8ff,#f92672,normal
Highlight6=#f8f8ff,#ae81ff,normal
Highlight7=#a6e22e,transparent,normal
Highlight8=#fd971f,transparent,normal
Highlight9=transparent,#00ffff,normal
Highlight10=transparent,#40ff40,normal
Return=#c0c0ff,transparent,normal
Line=#c0c0c0,#e1e1e1,normal
PageBreak=transparent,#c0c0c0,normal
LineNumber=#7a4ba2,#c0c0ff,normal
Ruler=#7a4ba2,#c0c0ff,normal
Outside=transparent,transparent,normal

查询性能的跳跃

2009-12-20T20:47:00.003+08:00

今天遇到一个很奇怪的问题，两句差不多的sql，性能却有很大差别。

$ mysql test -e 'flush status;set profiling=1;select t from t where t like "%a%" order by id desc limit 9085,1;show profiles;show status;' > a.txt
$ mysql test -e 'flush status;set profiling=1;select t from t where t like "%a%" order by id desc limit 9086,1;show profiles;show status;' > b.txt
$ diff a.txt b.txt
2c2
< sportsman
---
> sportscasts
4c4
< 1 0.07678300 select t from t where t like "%a%" order by id desc limit 9085,1
---
> 1 0.24102700 select t from t where t like "%a%" order by id desc limit 9086,1
11c11
< Bytes_sent 297
---
> Bytes_sent 299
155c155
< Connections 219
---
> Connections 220
170c170
< Handler_read_prev 18633
---
> Handler_read_prev 18634
224c224
< Key_read_requests 1630
---
> Key_read_requests 2064
247c247
< Queries 1779817
---
> Queries 1779824
296c296
< Uptime 1419010
---
> Uptime 1419015

其中t上有索引(id,t)。limit的偏移量小于9085，或者大于9086时看上去查询时间是和偏移量成正比的。
不知道为什么会有一个跳跃，感觉可能是触发了某个开关，导致两者的查询方式有区别。不过从状态信息上没看出来。

上面用的是5.1.40，换成5.1.41发现limit 9086,1变成0.12秒了，正常了一点，不过从change log上没有看上任何相关的东西。

ext3 文件反删除

2009-08-18T18:00:00.001+08:00

看到一个 ext3 上文件反删除的工具，尝试了一下，不过因为我服务器上的分区没有办法umount，所以没成功，不过看他写的帮助倒是对ext3的文件系统结构有了更深的了解。对于文件被删除而绝望的人可以自己试试。还有另一个工具，http://www.cgsecurity.org/wiki/TestDisk_Download，不过这个完全没有看了。

ssd 读写性能

2009-08-18T17:58:00.001+08:00

在某人的幻灯片上看到下面关于flash磁盘性能的一些总结，记录一下


                Read B/W        Write B/W       Erase Lat.      Read Lat.       Cost per GB
HDD             100 mb/s        150.00 mb/s                     5,000.00 us     $0.10
NAND MLC        250 mb/s        70.00 mb/s      3.5 ms          85.00 us        $3.50
NAND SLC        250 mb/s        170.00 mb/s     1.5 ms          75.00 us        $11.00
NOR SLC         58 mb/s         0.13 mb/s       5,000.00 ms     0.27 us         $70.00
DRAM            2,000 mb/s      2,000.00 mb/s                   0.08 us         $75.00

erlang的匿名递归函数

2009-03-23T00:03:00.002+08:00


spawn(
  fun() ->
    F = fun(This, X) ->
      error_logger:error_msg("~p~n", [X]),
      receive after 3000 -> void end ,
      This(This, X+1) end,
    F(F, 0) end
).

比较绕，没有什么更直接的方法了。需要定义一个辅助函数，恩，自己体会吧，不知道该怎么解释。

flash socket的授权

2009-03-22T23:46:00.003+08:00

这两天看了下flash的编程。我现在似乎对socket的部分兴趣更大一些，以前都是对动画感兴趣，因为比较炫。后来大概是觉得对图像没天份，还是老老实实的做系统比较好。

下了一个两三年前的开源程序，但就是运行不起来，说是没有许可连接。网上可以收到不少文章，说是加一个crossdomain.xml的策略文件就可以了。但尝试了很久都不行，再深入搜索才知道原来是在去年8月的flash 9的某个版本中做了调整，之前看的文章都太旧了。新的规则是用socket连接不能使用http上的策略文件了，必须要使用xmlsocket发送策略文件的内容。xmlsocket的端口在1024以下的，策略文件可以开放所有端口，否则只能开发1024以上的端口。使用

security.loadPolicyFile("xmlsocket://192.168.1.1:843");

加载策略文件。

flash会向server发送

<policy-file-request/>

并以\0结束，请求策略文件，server发送文件内容，同样以\0结尾。


<?xml version="1.0"?>
<!DOCTYPE cross-domain-policy
SYSTEM "http://www.adobe.com/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy>
   <site-control permitted-cross-domain-policies="all"/>
   <allow-access-from domain="*" to-ports="*" />
</cross-domain-policy>

还用不惯erlang

2009-02-02T01:28:00.002+08:00

断断续续的看了几周erlang，然后用一天写了个聊天室的原型，再用一天写了web接口和网页的demo，不过第二天基本在看inets的文档和调js，接口倒是很简单。总得来说用erlang写东西还是挺方便的，和perl同年生的东西啊，虽然用的人不多，但库还是不少的。虽然看了本书，但还只是了解了几个很常用的。而且函数模块的命名有些很奇怪，总是会忘记名字是什么。现在对otp还不是很明白，书上内容太少了，仍然需要看文档才行。

写程序有一些很不爽的地方，没有return语句，然后条件判断if和case里要把所有可能情况都写上，否则就会抛异常，搞得一个程序要是分支多一点就要拼命的缩进。因为用匹配很多，而两个匹配的处理可能只有一点差别，结果就要把相同的语句在每个匹配的分支好一遍，为这一两句写一个函数又觉得不值得，怎么看都不舒服。感觉不想写条件语句，不像其它语言中写if很随意的，不明原因。可能还没有体会到erlang的风格，需要多看看别人的代码。

跨域ajax请求

2009-02-02T01:10:00.003+08:00

刚放假回来，今天一帮搞js的人居然都不在。要写一个跨域的ajax的请求，用的是jquery。它包含带了一些ajax方法，可是文档太不详细了，看到可以使用.getJSON请求异域的json文件，因为js文件可以跨域。文档里写jquery会自动执行一个回调函数，看了半天也没明白什么意思。还是google比较快。用getJSON请求时，jquery会自动在url上加两个参数，jsoncallback=XXXA和_=XXXB，后一个不知道有什么，反正问题解决了就没管了。请求的url返回的json文件应该有这样的内容：XXXA(json_struct)，如XXXA({"name":"w","channel":"chat123"})，jquery会把文本数据自动生成为js的数据结构，然后传给getJSON中指定的回调函数。jquery文档中只说明了客户端的部分，没有说服务器端输出的文件内容是特殊的。可能是json调用的协议吧，js用得少，完全不知道。如果json文件中的内容不符，则回调函数不会执行，.ajaxSuccess， .ajaxComplete，.ajaxXXX...事件好像都不会触发，没想到有什么办法分辨ajax访问还没有结束和文件内容出错。

erlang和haskell

2009-01-11T00:07:00.003+08:00

3年前学haskell，完全是因为pugs是用haskell写的。之前为了用emacs看过一些lisp的东西，函数语言也不算完全陌生。但总觉用haskell写算法实现不错，真的要用它做一个可以用的东西还是有点不太实际，总的来说只是学着玩的。而同为函数语言，erlang原本是用于电信行业，至少看得到应用，让人觉得有了那么一点不是玩的意思。

和haskell比起来，erlang的语法让人觉得有些别扭，看上去也不是那么清爽。小于等于用=<，真是不习惯。列表，元组的括号成堆，还是少写些数据处理的程序比较好，否则近视又要加深了。

erlang学习

2009-01-10T23:26:00.003+08:00

Erlang程序设计第8章的习题：


start(N,M) ->
    statistics(wall_clock),
    Pids = for(1,N,fun(_X) -> spawn(fun get_msg/0) end),
    for(1,M,fun(X)->send_msg(Pids, "message " ++ integer_to_list(X)) end),
    {_,Time} = statistics(wall_clock),
    io:format("take ~p seconds~n", [Time/1000]),
    send_msg(Pids, stop),
    ok.

for(N,N,F) ->
    [F(N)];
for(I,N,F) ->
    [F(I)|for(I+1,N,F)].

get_msg() ->
    receive
         stop ->
             void;
         _Any ->
%            io:format("got ~p~n", [_Any]),
             get_msg()
    end.

send_msg([Pid], Msg) -> Pid!Msg;
send_msg([Pid|Pids], Msg) ->
    Pid!Msg,
    send_msg(Pids, Msg).

在笔记本上跑start(1000,1000)要0.4秒，而在一台双CPU的服务器上居然要1.3秒。以为是linux上编译erlang时有优化参数没有设好。看README，注意到默认是打开SMP模拟器的，于是试着使用

erl -smp disable

启动erl shell将smp模拟器关掉，结果CPU占用率从170%下降到100%，时间变成了0.3秒，看来模拟器的效率还不够好啊。

Firefox 扩展开发初试

2008-12-25T14:47:00.005+08:00

简述

Firefox的扩展开发主要使用JavaScript。界面的制作用XUL，并且可以配合CSS使用。Mozilla的核心XPCOM——跨平台组件模型，提供了一套组件和类，用于诸如内存管理，线程，基本数据结构等，这些都可以在扩展中使用。

Firefox中有Chrome的概念。Chrome 指的是应用程序窗口的内容区域之外的用户界面元素的集合，这些用户界面元素包括工具条，菜单，进度条和窗口的标题栏等。Chrome 提供者能为特定的窗口类型（如浏览器窗口）提供 chrome。有三种基本的 chrome 提供者：

内容（Content）：通常是 XUL 文件。
区域（Locale）：存放本地化信息。
皮肤（Skin）：描述 chrome 的外观。通常包含 CSS 和图像文件。

开发环境

有一些Firefox的扩展是专门为开发者提供的，使用它们可以使开发更加方便。为了不影响FF使用环境，我们可以用-P参数启动FF创建一个新的配置文件。然后安装下面的扩展：

JavaScript Debugger，做JS的调试

Extension Developer，一些开发工具

Console²，扩展的错误控制台

Chrome List，查看Chrome

Firebug，用于查看DOM

为了调试容易，还需要设置下面FF的环境参数，在地址栏中输入about:config，然后进行修改

javascript.options.showInConsole = true //把 JavaScript 的出错信息显示在错误控制台
nglayout.debug.disable_xul_cache = true //禁用 XUL 缓存，使得对窗口和对话框的修改不需要重新加载 XUL 文件
browser.dom.window.dump.enabled  = true //允许使用 dump() 语句向标准控制台输出信息
javascript.options.strict        = true //在错误控制台中启用严格的 JavaScript 警告信息

在 Windows 上，为了可以在js中使用 dump 调试，在FF启动时还需要增加启动参数 -console。

扩展的目录结构

FF的扩展都是以.xpi的文件形式发布，xpi文件实际上就是一个zip文件更改了后缀名。可以通过这个Extension Wizard来生成一个目录结构。如下：

exname
|   build.sh             # 两个sh的脚本在windows下没有什么用处，可以直接删掉
|   chrome.manifest      # Chrome 注册的清单文件
|   config_build.sh
|   install.rdf          # 扩展安装信息
|   readme.txt
|
+---content
|       firefoxOverlay.xul  # 覆盖的界面
|       options.xul         # 选项设置的界面
|       overlay.js          # 覆盖的程序
|
+---defaults
|   \---preferences
|           exname.js       # 选项的默认值
|
+---locale
|   \---en-US               # 英语文件
|           exname.dtd
|           exname.properties
|           prefwindow.dtd
|
\---skin
        overlay.css         # 样式文件

其中除了chrome.manifest和install.rdf的文件名是固定的，其他文件的名字都随意的。content目录下一般存放扩展界面和程序文件。defaults/preferences下存放扩展选项的默认值文件，FF会自动读取这个目录下所有js的文件，所以文件名是任意的。locale下是各种语言文件，如果扩展支持多语言，那么每一种语言对应到locale下的一个子目录，子目录的名字是像en-US，zh-CN这样的语言代码。skin目录下存放CSS文件，图标之类的。

把这个exname目录拷贝到FF扩展的目录下，一般是

C:\Documents and Settings\<用户名>\Application Data\Mozilla\Firefox\Profiles\<配置文件对应的子目录>\extensions

。然后把目录名由exname改为install.rdf中指定的扩展的ID，FF启动时会自动识别并加载这个新的扩展。

对扩展做了修改之后，不需要重启FF，只要安装了Extension Developer，在Tools菜单中选择

Extension Developer > Reload all Chrome

就可以了。

下载示例中的扩展Content Filter。这个扩展的功能是对匹配url的网页，查找所有的find并替换为replace。

install.rdf

这个文件中是扩展的安装信息。
如：

<?xml version="1.0" encoding="UTF-8"?>
<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
 xmlns:em="http://www.mozilla.org/2004/em-rdf#">
  <Description about="urn:mozilla:install-manifest">

    <em:id>contentfilter@adways.net</em:id>
    <em:name>Content Filter</em:name>
    <em:version>1.0</em:version>
    <em:creator>Jedy</em:creator>

    <em:homepageURL>http://my.homepage.net/</em:homepageURL>
    <em:description>Content Filter</em:description>
    <em:optionsURL>chrome://contentfilter/content/options.xul</em:optionsURL>
    <!-- em:iconURL>chrome://contentfilter/content/xxx.png</em:iconURL-->

    <!-- Firefox -->
    <em:targetApplication>
      <Description>
        <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
        <em:minVersion>3.0</em:minVersion>

        <em:maxVersion>3.0.*</em:maxVersion>
      </Description>
    </em:targetApplication>
  </Description>
</RDF>

这个文件里需要设置扩展的id，这也是扩展的目录名。设置了optionsURL的话，就可以在FF的扩展列表中使用选项按钮打开这里设置的选项界面。

{ec8030f7-c20a-464f-9b0e-13a3a9e97384}

是Firefox的id，不用更改的，如果扩展还支持Thundbird等其他的Mozilla程序，那么这里会有另一段targetApplication的信息，这会使用其他程序的id。minVersion和maxVersion设置了扩展适合的程序版本，FF的扩展兼容性检查就是查这里的信息。所以如果有的扩展在FF升级后没有升级，结果不能通过兼容性检查，那么可以自己把xpi文件下载下来后改一下maxVersion之后再安装，有不少情况都是可以直接用的。

chrome.manifest

这个内容如下：

content   contentfilter   content/
overlay   chrome://browser/content/browser.xul   chrome://contentfilter/content/overlay.xul

content行告诉FF可以在content/目录下找到contentfilter的content文件，设置的目录路径是相对于chrome.manifest所在目录的路径。overlay行设置了对浏览器的覆盖文件。这里还可以设置skin，locale的目录等。

Mozilla通过overlay的方式使扩展可以直接更改浏览器的界面，比如可以在菜单栏上增加一组菜单，可以在状态栏上增加图标等。

overlay

通过overlay，在FF的tools菜单上增加了一个菜单项：

<?xml version="1.0"?>
<overlay id="contentfilter-overlay" xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
   <script type="application/x-javascript;version=1.7" src="overlay.js" />
   
   <menupopup id="menu_ToolsPopup">
       <menuitem id="contentfilter-open" label="Content Filter..." insertafter="prefSep" oncommand="contentFilter.openConfig()" />
   </menupopup>

</overlay>

扩展使用XUL来描述界面。XUL文件实际上就是一个XML文件，其中可以使用JS和CSS定义行为和样式。

上面的文件中，id为menu_ToolsPopup的menupopup就是FF中工具菜单，menuitem这句在菜单中插入了一个“Content Filter...”的菜单项，插入的位置是在prefSep分隔之后，点击时执行contentFilter.openConfig函数。这里使用的各个FF中组件的id，在安装了Chrome List扩展之后，都可以通过工具菜单的

Explore Chrome...

，打开

browser/content/browser.xul

查到。

XUL

写XUL和写HTML差不多，只是元素的名字不一样，格式上更严格一些。Mozilla的所有程序都是使用XUL描述界面的。它不仅用于扩展，还可以直接用于编写应用程序。有兴趣的可以看这些网站：

http://xulplanet.com/references/elemref/, XUL的手册，刚写扩展时要经常查阅

https://developer.mozilla.org/En/XUL_Tutorial, 一篇XUL入门教程

https://developer.mozilla.org/en/Getting_started_with_XULRunner, 使用XUL开发应用程序

用XUL编写的程序需要XULRunner的运行环境，这跟java差不多。从FF3开始，FF中已经自带XULRunner，可以直接用Firefox的程序文件执行XUL的程序。如下载这个例子，解压到一个目录中，然后运行

firefox.exe -app application.ini

就能执行这个程序。

选项菜单

在XUL中可以使用dialog标签创建一个选项对话框，如例子中的options.xul文件。

<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
<dialog
    id="contentfilter-configwindow"
    title="Content Filter"
    buttons="accept, cancel"
    onload="init();"
    ondialogaccept="save();"
    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
...
</dialog>

dialog的buttons属性定义了不同的按钮，onload属性定义了对话框在载入时执行的函数，ondialogaccept属性定义了点击accept按钮时执行的函数。因为是XML格式的文件，所以如果要直接在文件中写js的代码需要使用

<![CDATA[ ]]>

包含起来。options.xul中定义了一系列的js函数，这些都对应到一些点击或按键的动作。还可以使用js在操纵XML的DOM树，方法和HTML中是基本一致的。如：

<script type="application/x-javascript;version=1.7">
<![CDATA[
function deletePattern() {
   var list = document.getElementById("patternList");
   var delItems = list.selectedItems;
   for(var i = delItems.length - 1; i >= 0; i--)
      list.removeChild(delItems[i]);
}
]]>
</script>
<listbox width="480px" id="patternList" seltype="multiple" onkeypress="pressDel(event);">

在listbox上按键会触发pressDel函数，这个函数使用对象的removeChild方法移除DOM树中的一个子节点。

扩展功能

对于一个实用的扩展来说，通常只有一个选项对话框是不够的，还需要注册一些事件监听函数，或者菜单项提供一个事务处理的入口。见overlay.js：

var contentFilter = {
   init: function() {
      var appcontent = document.getElementById("appcontent");
      appcontent.addEventListener("DOMContentLoaded", contentFilter.filter, true);
      contentFilter.patterns.loadAsRegex();
   },

   filter: function(aEvent) {
      var doc = aEvent.originalTarget;
      if (doc.nodeName != "#document") return;
      var docElement = doc.documentElement;
      var p = contentFilter.patterns.patternList;
      for (var i = 0; i < p.url.length; i++) {
         if(p.url[i].test(doc.location)) {
            docElement.innerHTML = docElement.innerHTML.replace(p.find[i], p.replace[i]);
         }
      }
   },
...
};

window.addEventListener("load", function() { contentFilter.init(); }, false);

最后一行定义了一个window.load的监听器，当打开FF的窗口时触发。init函数的定义了页面加载时的监听器并调用了loadAsRegex方法载入配置。

这里定义的contentFilter变量是处于当前窗口的命名空间下，并不是全局的变量，所以在选项对话框中并不能直接调用。因此在options.xul的save函数中

var win= Components.classes["@mozilla.org/appshell/window-mediator;1"].
   getService(Components.interfaces.nsIWindowMediator).getEnumerator("navigator:browser");
while(win.hasMoreElements()) {
   var browser = win.getNext();
   browser.contentFilter.patterns.loadAsRegex();
}

使用了getEnumerator得到所有的浏览器窗口，然后让每一个窗口中的contentFilter对象重新加载配置。

配置

扩展的默认配置参数可以在defaults/preferences目录下定义，如prefs.js：

pref("extensions.contentfilter.url", "baidu");
pref("extensions.contentfilter.find", "hao123");
pref("extensions.contentfilter.replace", "kaixin");

可以在about:config中查找扩展的配置参数。一般命名的方法是extensions.<扩展名>.<参数名>，当没有定义用户的值时，FF会读取这些默认的值。

在程序中可以使用

var prefs = Components.classes["@mozilla.org/preferences-service;1"].
   getService(Components.interfaces.nsIPrefService);

得到配置树，然后在找到某个分支

var branch = prefs.getBranch("extensions.contentfilter.");

配置中有4个值的类型：布尔值，整值，字符串和复杂类型。取一个字符串值可以使用getCharPref，如：

branch.getCharPref("name");

这里就是取得extensions.contentfilter.name的值，要注意的是getBranch不会做解析，所以

prefs.getBranch("extensions.contentfilter.na").getCharPref("me")

也是取extensions.contentfilter.name的值，因此，一般在使用getBranch时，branch都是以.结尾的。

发布

讲整个扩展目录下的文件压缩为zip格式，install.rdf为第一层，不要包含扩展本身的目录，然后改后缀为xpi。将这个文件拖到FF中，就会弹出对话框询问是否要安装了。

总结

开发一个功能简单的扩展是很容易的。不过感觉官方的文档不够详细，或者组织的不是很好，想实现个功能很难找到应该怎么做，使用什么API，很多细节的地方不知道该怎么处理。可能要把所有文档浏览一遍才能比较顺手吧。新手可以多看看Code Snippets或其他人的扩展。

参考链接

cluster性能测试

2008-11-03T09:24:00.004+08:00

测试环境

服务器: 192.168.1.1，192.168.1.2，192.168.1.3，192.168.1.4，192.168.1.5
CPU: 1～3为Intel(R) Pentium(R) D CPU 2.80GHz， 4、5为Intel(R) Xeon(R) 3040 1.86GHz
操作系统: Centos 4.4
Cluster版本: 5.1.27-ndb-6.3.17-cluster-gpl-log MySQL Cluster Server (GPL)
测试软件: sysbench

Cluster结构

192.168.1.1，192.168.1.2，192.168.1.3，192.168.1.4为data node，192.168.1.5为management node和sql node。192.168.1.4为第二台sql node，并运行sysbench。

Cluster中NoOfReplicas设为2，即每行数据储存两次，到两台data node上。

测试结果

测试是使用sysbench的oltp测试模式进行的，它的测试查询以事务为单位，一个事务中包含了联机事务处理中常见的读和写操作。测试表的行数为100万，对1到128个线程并发做了测试。其中Innodb的测试数据作为比较。innodb设置了足够大的buffer_pool，能够把整张表缓存到内存里。Cluster的测试中，除了内存选项，其他都是默认配置，在一个测试中出现错误没有完成，是因为资源的限制导致错误，只是查询失败，集群并没有出现问题。

"2 data"的测试是使用2个data node的结果，NoOfReplicas同样是2，即两台数据节点中的内容完全相同。比较它和"4 data"的结果可以看出，虽然增加了节点，但由于增加了节点之间的通讯的消耗，查询的速度并没有提升反而下降。增加了节点的优势在于大并发量，当只有一个sql node时，这个节点成为瓶颈，所以4个data node的优势没有表现出来。当使用两个sql node时，比较"2 data + 2 sql"和"4 data + 2 sql"就可看到使用更多的节点可以提高并发量。"4 data, disk"是使用硬盘的表格式测试，每个节点上表文件的大小为120M左右，用于缓存表内容的内存大小设置为64M，即表的内容不能完全缓存到内存中。这样在查询中需要硬盘的随机读写，使得查询的速度和并发量都有大幅下降。

	线程数	innodb	2 data + 1 sql	2 data + 2 sql	4 data + 1 sql	4 data + 2 sql	4 data, disk
每秒事务数	1	202.05	95.52	-	46.75	-	16.02
平均响应时间（秒）	1	0.0049	0.0105	-	0.0214	-	0.0624
每秒事务数	2	358.21	153.05	-	94.65	-	24.74
平均响应时间（秒）	2	0.0056	0.0131	-	0.0211	-	0.0808
每秒事务数	4	539.47	249.31	-	187.92	-	46.08
平均响应时间（秒）	4	0.0074	0.016	-	0.0213	-	0.0868
每秒事务数	8	616.36	340.24	-	295.99	-	83.07
平均响应时间（秒）	8	0.013	0.0235	-	0.027	-	0.0962
每秒事务数	16	574.6	427.09	-	404.7	-	94.71
平均响应时间（秒）	16	0.0278	0.0374	-	0.0395	-	0.1688
每秒事务数	32	538.16	431.75	413.09	421.8	491.55	97.42
平均响应时间（秒）	32	0.0594	0.0741	0.0774	0.0758	0.065	0.3281
每秒事务数	64	497.74	390.83	401.09	385.5	498.05	×
平均响应时间（秒）	64	0.1285	0.1637	0.1595	0.166	0.1294	×
每秒事务数	128	453.15	-	382.24	-	461.39	-
平均响应时间（秒）	128	0.2824	-	0.3348	-	0.2782	-

表中"-"代表没有进行测试，"×"代表测试中出现错误。

cluster中增加或减少数据节点

2008-10-21T16:40:00.003+08:00

增加或减少数据节点的数量和NoOfReplicas有关，一般来说NoOfReplicas是2，那么增加或减少的数量也应该是成对的，否则要设置另外的NoOfReplicas。增减节点时需要重启整个cluster，并使用某个备份进行恢复。使用cluster自己的备份机制，备份后每个数据节点上有一组备份的文件。恢复时需要对每一组文件运行一次ndb_restore，即原来的数据节点有多少个就运行多少次，不管增减后有多少个数据节点。其中-b始终是一样的，-n指定原来的node id。

Innodb_os_log_written

2008-09-25T18:17:00.002+08:00

从 Innodb_os_log_written 可以知道 innodb 日志的写入量，从而判断 innodb_log_buffer_size 的大小是否合适，同时也可以估计出一个 log_file 大概能支持多长时间。innodb 当buffer满了，事务提交或每秒1次刷新，看哪个更早发生。

query cache的存储方式

2008-09-24T09:44:00.005+08:00

当查询进行时，如果设置了query cache，MySQL会把查询的结果保存在qc中。保存并不是在结果集完全得到的时候进行的，而是一边检索一边保存，MySQL每次会分配一块大小为query_cache_min_res_unit的内存用于保存结果集，当使用完之后再分配一块，所以如果结果集大于query_cache_min_res_unit会使得在一次查询中进行多次内存的分配。

当最后一块分配的内存没有完全使用时，MySQL会把这块内存截断，并把没有使用的那部分归还以重复利用。但是当多个query同时进行时，可能归还的部分无法和空余的内存合成连续的块而造成这部分大小小于query_cache_min_res_unit无法再分配，这样出现了无法再使用的内存碎片。一个连续的同一类型的内存块称为block，包含使用的块，也包含未使用的块。

Qcache_total_blocks 显示了所有的块数，而Qcache_free_blocks 反映了未使用的块数。如果Qcache_free_blocks很大，说明内存的碎片很多，内存的使用率会比较差，所以这时虽然Qcache_free_memory显示还有剩余的内存，也可能无法使用，当插入新的query时就需要清除旧的，使得Qcache_lowmem_prunes很高。可以使用flush query cache重整内存，操作之后Qcache_free_blocks应该为1，因为所有未使用的内存都放在一起作为连续的一块了。可以根据
query的大小调整query_cache_min_res_unit以更好地利用内存。可以使用

(query_cache_size - Qcache_free_memory）/ Qcache_queries_in_cache

计算query的平均大小。不过不是把query_cache_min_res_unit设得越小越好，因为频繁的分配内存会影响执行的速度。

我不知道一个query会使用几个block，对于一个刚使用qc，发现每加入一个query，block增加了2，但在一个运行的服务器上看到Qcache_queries_in_cache*2和Qcache_total_blocks要相差不少。

High Performance MySQL 2nd

2008-09-24T09:41:00.003+08:00

最近在看这本书，感觉比第一版内容充实了不少，讲得也比较清晰，深入。所以虽然讲的大部分东西都知道了，还是看得很仔细。顺便把一些以前理解不完全的东西写下来，加深印象。

使用load data infile时的字符集

2008-09-24T09:26:00.003+08:00

在High Performance MySQL 2nd上看到，load data infile在某些MySQL的版本上不支持指定导入时的字符集。这时，MySQL假设导入文件的字符集是character_set_database，这个变量根据当前数据库指定的字符集而变化，如果没有指定当前数据库，那么它的值由character_set_server决定。因此如果load data infile不支持指定字符集，那么在导入前需要确认当前数据库的字符集，如果不符，则使用set character_set_database = ... 更改。

explain的误解

2008-09-19T20:14:00.003+08:00

发现MySQL的explain还是很有迷惑性的。

看下面两个sql的explain，(i,j)是tt的主键


mysql> explain select * from tt where i between 3 and 5 and j = 4\G
*************************** 1. row ***************************
          id: 1
 select_type: SIMPLE
       table: tt
        type: range
possible_keys: PRIMARY
         key: PRIMARY
     key_len: 8
         ref: NULL
        rows: 8
       Extra: Using where; Using index
1 row in set (0.00 sec)

mysql> explain select * from tt where i > 2 and i < 6 and j = 4\G
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tt
         type: range
possible_keys: PRIMARY
          key: PRIMARY
      key_len: 4
          ref: NULL
         rows: 8
        Extra: Using where; Using index
1 row in set (0.00 sec)

看上去如果使用了between，那么MySQL可以用的索引的两列。但仔细的研究了一下，发现实际并不是这样。between 3 and 5可以写为(i>3 or i=3) and (i<5 or i=5)，是这两个等号使用了两列，而大于和小于的判断仍然是index扫描，只用了一列。

再看另一个


mysql> explain select * from tt where i in (3,4,5) and j=4\G
*************************** 1. row ***************************
          id: 1
 select_type: SIMPLE
       table: tt
        type: range
possible_keys: PRIMARY
         key: PRIMARY
     key_len: 8
         ref: NULL
        rows: 3
       Extra: Using where; Using index
1 row in set (0.00 sec)

这个才是真正用了两列，可以看到这里估计的行数是3，而刚才两个是8。用 show status 可以看得更清楚一些：


mysql> show status like 'handler_read%';
+-----------------------+-------+
| Variable_name         | Value |
+-----------------------+-------+
| Handler_read_first    | 0     |
| Handler_read_key      | 0     |
| Handler_read_next     | 0     |
| Handler_read_prev     | 0     |
| Handler_read_rnd      | 0     |
| Handler_read_rnd_next | 0     |
+-----------------------+-------+
6 rows in set (0.00 sec)

mysql> select * from tt where i in (3,4,5) and j=4;
+---+---+
| i | j |
+---+---+
| 3 | 4 |
+---+---+
1 row in set (0.00 sec)

mysql> show status like 'handler_read%';
+-----------------------+-------+
| Variable_name         | Value |
+-----------------------+-------+
| Handler_read_first    | 0     |
| Handler_read_key      | 4     |
| Handler_read_next     | 1     |
| Handler_read_prev     | 0     |
| Handler_read_rnd      | 0     |
| Handler_read_rnd_next | 0     |
+-----------------------+-------+
6 rows in set (0.00 sec)

mysql> select * from tt where i between 3 and 5 and j = 4;
+---+---+
| i | j |
+---+---+
| 3 | 4 |
+---+---+
1 row in set (0.00 sec)

mysql> show status like 'handler_read%';
+-----------------------+-------+
| Variable_name         | Value |
+-----------------------+-------+
| Handler_read_first    | 0     |
| Handler_read_key      | 6     |
| Handler_read_next     | 10    |
| Handler_read_prev     | 0     |
| Handler_read_rnd      | 0     |
| Handler_read_rnd_next | 0     |
+-----------------------+-------+
6 rows in set (0.00 sec)

后一个sql中有9次read_next_key，说明做了索引扫描。

如何编写MySQL的全文索引插件

2008-06-14T09:27:00.000+08:00

说明

在MySQL5.1中可以为全文索引编写插件。插件的作用是代替MySQL内部的分词模块。我们知道MySQL自带的分词只是通过空格和控制符将词分开，对于英语来说，可以通过这种方式分词，但中文是没有空格的，所以MySQL本身的全文索引不支持中文。我们可以通过全文索引分词插件的方式让MySQL可以对中文分词，从而使得MySQL的全文索引支持中文。

设置了MySQL的插件之后，当我们插入或者更新在全文索引中的字段时，MySQL使用插件对字段进行分词。当对这个索引进行检索时，也需要使用插件对检索的关键字进行分词。

安装

需要从C或C++编写插件，编译为so文件。编译时需要定义MYSQL_DYNAMIC_PLUGIN。某些平台下的gcc可能还要加上-D_GNU_SOURCE，否则会报错。

gcc -fPIC -DMYSQL_DYNAMIC_PLUGIN -Wall -shared -I /usr/local/mysql-5.1.25/include/ \
 -I /usr/local/mysql-5.1.25-rc/include/ \
 -I /usr/local/mysql-5.1.25-rc/  \
 -o libthunder_ft.so thunder_ft.c

然后放在plugin_dir启动选项定义的目录下，默认是MySQL安装目录下的lib/plugin目录。然后使用

INSTALL PLUGIN plugin_name SONAME 'plugin_library'

安装插件。

删除可以使用

UNINSTALL PLUGIN plugin_name

如果删除了一个全文索引插件，那么使用了这个插件的表将不可用，不能对该表做任何操作。

代码

每一个插件都要提供一个st_mysql_plugin结构

struct st_mysql_plugin
{
 int type;             /* the plugin type (a MYSQL_XXX_PLUGIN value)   */
 void *info;           /* pointer to type-specific plugin descriptor   */
 const char *name;     /* plugin name                                  */
 const char *author;   /* plugin author (for SHOW PLUGINS)             */
 const char *descr;    /* general descriptive text (for SHOW PLUGINS ) */
 int license;          /* the plugin license (PLUGIN_LICENSE_XXX)      */
 int (*init)(void *);  /* the function to invoke when plugin is loaded */
 int (*deinit)(void *);/* the function to invoke when plugin is unloaded */
 unsigned int version; /* plugin version (for SHOW PLUGINS)            */
 struct st_mysql_show_var *status_vars;
 void * __reserved1;   /* placeholder for system variables             */
 void * __reserved2;   /* placeholder for config options               */
};

用plugin.h中的宏mysql_declare_plugin定义，如：

mysql_declare_plugin(thunder_ft)
{
       MYSQL_FTPARSER_PLUGIN,     /* type                            */
       &thunder_ft_descriptor,    /* descriptor                      */
       "thunder_ft",              /* name                            */
       "Jedy",                    /* author                          */
       "A fulltext plugin",       /* description                     */
       PLUGIN_LICENSE_GPL,
       thunder_ft_plugin_init,    /* init function (when loaded)     */
       thunder_ft_plugin_deinit,  /* deinit function (when unloaded) */
       0x0001,                    /* version                         */
       thunder_status,            /* status variables                */
       NULL,                      /* system variables                */
       NULL
}
mysql_declare_plugin_end;

init和deinit两个函数用于插件的初始化和卸载，在install，uninstall或者server启动停止时执行一次，我们可以用这两个函数分配和收回一些资源。

status_vars是一个st_mysql_show_var结构，定义如下：

struct st_mysql_show_var {
 const char *name;
 char *value;
 enum enum_mysql_show_type type;
};

其中value是一个char指针，MySQL会按照enum_mysql_show_type的类型将这个指针转为符合类型的指针。的元素为

SHOW_BOOL	Pointer to a boolean variable
SHOW_INT	Pointer to an integer variable
SHOW_LONG	Pointer to a long integer variable
SHOW_LONGLONG	Pointer to a longlong integer variable
SHOW_CHAR	A string
SHOW_CHAR_PTR	Pointer to a string
SHOW_ARRAY	Pointer to another st_mysql_show_var array
SHOW_FUNC	Pointer to a function
SHOW_UNDEF	undefined

status_vars指向一个结构数组，数组最后一行为{0,0,0}（有些编译器中要写为{0,0,SHOW_UNDEF}，否则会报错）代表数组结束。之前的每一行为一个状态值。

我们还需要申明一个st_mysql_ftparser结构：

struct st_mysql_ftparser
{
 int interface_version;
 int (*parse)(MYSQL_FTPARSER_PARAM *param);
 int (*init)(MYSQL_FTPARSER_PARAM *param);
 int (*deinit)(MYSQL_FTPARSER_PARAM *param);
};

init是初始化函数，在每个使用到parser的语句之前调用，deinit在parser函数之后调用。比如一次insert多行，init调用一次，然后调用多次parser进行分词，每一行都处理完成之后调用deinit。例如：

static struct st_mysql_ftparser thunder_ft_descriptor={
   MYSQL_FTPARSER_INTERFACE_VERSION, /* interface version      */
   thunder_ft_parse, /* parsing function       */
   thunder_ft_init, /* parser init function   */
   thunder_ft_deinit /* parser deinit function */
};

传给这三个函数的参数MYSQL_FTPARSER_PARAM定义如下：

typedef struct st_mysql_ftparser_param
{
 int (*mysql_parse)(struct st_mysql_ftparser_param *,
                    char *doc, int doc_len);
 int (*mysql_add_word)(struct st_mysql_ftparser_param *,
                       char *word, int word_len,
                       MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info);
 void *ftparser_state;
 void *mysql_ftparam;
 struct charset_info_st *cs;
 char *doc;
 int length;
 int flags;
 enum enum_ftparser_mode mode;
} MYSQL_FTPARSER_PARAM;

其中mysql_parse是MySQL内部parser的回调函数。mysql_add_word是分词后将词传给MySQL的函数。 ftparser_state用于给编写者保存一定的状态信息，可以是任何的指针。 cs是字符集的指针，可以由之得到传入文本的字符信息。doc是需要parser的文本指针，length是其长度。这里的doc不是以\0结尾的字符串，所以一定要通过length处理。flags目前只有MYSQL_FTFLAGS_NEED_COPY这样一个非零值，告诉MySQL mysql_add_word添加的词需要进行拷贝，比如算法是每次parser把doc拷贝到一个buffer中处理，而返回这个buffer中词的指针时需要设置MYSQL_FTFLAGS_NEED_COPY，因为buffer的值在处理过程中会变化的。mode用于区别是普通分词还是 boolean的分词。

MYSQL_FTPARSER_FULL_BOOLEAN_INFO的分词只是用于解析boolean检索时的条件，建索引时始终使用的是MYSQL_FTPARSER_SIMPLE_MODE。

MySQL函数

实现分词可以使用完全独立的函数也可以使用一些MySQL的函数。MySQL中提供了btree的实现，可以直接使用。另外MySQL分配和释放内存也是使用了自己定义的函数my_malloc和my_free，它们的第二个参数说明了出错的处理，一般设为MYF(MY_WME)即可。

使用get_charset_by_csname可以返回一个charset_info_st结构的指针，三个参数分别为字符集名字的字串，类型和错误处理的flag。

param->cs->cset->ctype(param->cs, &ctype, (uchar*) doc, (uchar*) end)返回对应param->cs字符集的一个字符的长度，ctype的值反映了一些这个字符种类的信息，比如字母，空格或控制符等。在utf8 字符集中汉字既是大写字母又是小写字母。

MySQL全文检索插件

2008-06-13T14:32:00.003+08:00

hightman实现了一个MySQL全文检索的插件。它只能使用在5.1.11-12，并且需要更改MySQL的源码，故对其做了一些修改，替换了一个MySQL后续版本中更改了的接口，去掉了一些不需要的功能。

hightman的插件使用了自己的wordlist和stopword list，并使用正向最大匹配分词，新的插件对算法没有任何改变。插件只支持utf8，就是说用于建索引的字段的字符集必须为utf8。wordlist 中只有26万的词汇，可能分词不是很准确，因为我不太清楚好的分词是什么样子，所以也说不准。支持normal mode和boolean mode，不支持query expansion。分词的速度大概为65M的文本建索引需要85秒（没比较，不知道是快还是慢）。源码见最后的链接。

使用方法：

1. 编译插件，MySQL必须是5.1.12版之后的版本，编译出来的so文件必须放在MySQL安装目录的lib/plugin目录下

shell> gcc -DMYSQL_DYNAMIC_PLUGIN -Wall -shared \
-I/usr/local/mysql/include \
-I/usr/local/mysql-source/include \
-I/usr/local/mysql-source \
-o /usr/local/mysql/lib/plugin/libthunder_ft.so \
thunder_ft.c

2. 拷贝wordlist，将附件中的wordlist和stopword两个文件放到/usr/local/mysql/share/mysql中

3. 进入mysql，安装插件

mysql> install plugin thunder_ft soname 'libthunder_ft.so';

4. 建索引时增加 with parser thunder_ft 修饰

mysql> alter table review add fulltext index i_title_content(title, content) with parser thunder_ft;

5. 使用全文索引

mysql> select * from review where match(title, content) against('+大显 +手机' in boolean mode);

注意match中必须列出索引中的每一项。如果希望对title单独检索，则必须要为title这一列单独建一个索引。

6. 可以查看插件被调用了多少次用于分词

mysql> show global status like 'thunder_ft_called';

7. 因为要将wordlist放在内存中，所以这个插件会使用十几兆的内存。当不需要使用时，可以卸载。

mysql> uninstall plugin thunder_ft;

thunder_ft.c
wordlist

设置MySQL使用大内存页面

2008-05-04T15:17:00.002+08:00

一般情况下使用的内存为每页4K，使用 huge page 的话默认是每页 2M。如果设置MySQL使用 huge page 至少有两个好处，一个是可以减少 Translation Lookaside Buffer (TLB) 失误以提高性能，另一个是利用 huge page不会swap的特性保证MySQL的内存不会被交换到swap中。
MySQL 5.0.3之后在linux上支持huge page，可以使用 large-page 选项启动MySQL。
当然还有一些相关的系统设置。


echo 400 > /proc/sys/vm/nr_hugepages

这个指定总共huge page的页数，可以放到/etc/rc.local中。由于分配时需要有连续的内存空间，所以如果在运行了一段时间的系统上执行，可能无法分配到指定的数量，即使还有足够的内存。

之后还需要设置内核参数kernel.shmmax和kernel.shmall，否则MySQL启动时会报22的错误

InnoDB: HugeTLB: Warning: Failed to allocate 536887296 bytes. errno 22

shmmax是最大的共享内存段的大小，单位是字节，默认32M，肯定是不够的，这个应该比innodb_buffer_pool要大。shmall是共享内存的总大小，单位是页，默认2097152（8G）。可以使用sysctl -w或者在/etc/sysctl.conf中设置。

除此还需要设max locked memory，使用ulimit -l或设置/etc/security/limits.conf，否则会报12的错误：

Warning: Failed to allocate 31457280 bytes from HugeTLB memory. errno 12

MySQL启动之后可以使用

grep Huge /proc/meminfo

查看huge page的使用情况。

HugePages_Total:   400
HugePages_Free:    128
Hugepagesize:     2048 kB

禁用一个用户

2008-04-18T09:11:00.002+08:00

临时的禁用一个用户在MySQL中是不支持，不过还是有一些办法可以实现。
MySQL是支持SSL连接的，可以设置希望禁用用户的SSL连接使得该用户无法再连上。
比如把ssl_type从空字符串设为X509。

取随机记录

2008-04-15T14:49:00.003+08:00


set @a:=N+1, @b:=-1;
select * from t,
  (select id from t 
     where if(rand()*(M - (@b:=@b+1)) < @a, @a:=@a-1, 0)
     limit 10
  ) as tt 
where t.id = tt.id;

其中M是表的行数，这比order by rand() limit N将会快很多，而且应该是均匀随机的（感觉上是，懒的去证明了）。


DELIMITER $$

DROP PROCEDURE IF EXISTS `test`.`rand_rows` $$
CREATE PROCEDURE `test`.`rand_rows` (t varchar(64), id_col varchar(64), n int)
BEGIN
  set @rand_rows_i:=-1;
  set @rand_rows_table_count:=0;
  set @rand_rows_limit:=n+1;
  set @rand_rows_sql := concat('select count(*) from ', t, ' into @rand_rows_table_count');
  prepare st from @rand_rows_sql;
  execute st;
  deallocate prepare st;
  set @rand_rows_sql := concat('select * from ', t, ' as t1, ',
                '(select ', id_col,' from ', t,
                ' where if(rand()*(', @rand_rows_table_count, ' - (@rand_rows_i:=@rand_rows_i+1)) < @rand_rows_limit, @rand_rows_limit:=@rand_rows_limit-1, 0) limit ',
                @rand_rows_limit - 1, ' ) as t2 ',
                'where t1.', id_col,' = t2.', id_col);
  prepare st from @rand_rows_sql;
  execute st;
  deallocate prepare st;
  set @rand_rows_sql := null, @rand_rows_i := null, @rand_rows_table_count := null, @rand_rows_limit := null;
END $$

DELIMITER ;

replication的错误

2008-04-10T09:15:00.003+08:00

昨天replication又出问题了。master上更改了max_allowed_packet，但slave上的忘记改了，结果导致master上过大的SQLslave不能取到。之后虽然在slave上也更改了max_allowed_packet，但start slave仍然不能成功。错误日志中的记录是：


080409 18:37:31 [Note] Slave I/O thread exiting, read up to log 'mysql-bin.000251', position 607694155
080409 18:51:23 [Note] Slave SQL thread initialized, starting replication in log 'mysql-bin.000251' at position 605990219, relay log './mysql-relay-bin.001025' position: 89483173
080409 18:51:23 [ERROR] Error running query, slave SQL thread aborted. Fix the problem, and restart the slave SQL thread with "SLAVE START". We stopped at log 'mysql-bin.000251' position 605990219
080409 18:51:23 [Note] Slave I/O thread: connected to master 'replicate@192.168.1.169:3306',  replication started in log 'mysql-bin.000251' at position 607694155
080409 18:51:24 [ERROR] Error reading packet from server: log event entry exceeded max_allowed_packet; Increase max_allowed_packet on master ( server_errno=1236)
080409 18:51:24 [ERROR] Got fatal error 1236: 'log event entry exceeded max_allowed_packet; Increase max_allowed_packet on master' from master when reading data from binary log

注意红色的部分，605990219开始是一个长达18M的SQL，slave的sql thread执行到这一个sql出错了，不过不知道原因。而io thread读到了日志中的607694155。我们使用change master to应该是给sql thread设开始位置，所以用change master to把master_log_pos设为605990219，再运行start slave就可以了。

免费的flash图表

2008-03-30T22:46:00.001+08:00

看这个：
http://tutorialblog.org/free-chart-and-graph-solutions/

Charts and graphs help the user to visualise data in a more meaningfull way than rows of text statistics. They are extensively used in reporting applications, for displaying earnings, website traffic etc - here we take a look at some pre-made scripts and frameworks available to the web designer or web application developer …

Open Flash Chart - Open Flash Chart, is open source. It is free to use and you get the source code to fiddle with

amCharts - Pie and donut charts, line and area charts, column and bar charts, scatter and bubble charts and an interactive map tool are all free for download

Php / Swf Charts - PHP/SWF Charts is a simple, yet powerful PHP tool to create attractive web charts and graphs from dynamic data. Use PHP scripts to generate or gather the data from databases, then pass it to this tool to generate Flash (swf) charts and graphs. Any other scripting language (ASP, CFML, Perl, etc.) can be used with XML/SWF Charts (the XML version of the same tool.)

Fusion Charts Free - FusionCharts Free is a flash charting component that can be used to render data-driven & animated charts for your web applications and presentations

Yahoo! UI Library: Charts - The YUI Charts Control visualizes tabular data on a web page in several possible formats including vertical columns, horizontal bars, lines, and pies. Notable features include support for the DataSource Utility, customizable series and axes, a customizable mouse-over datatip, combination charts, and skinning

Flot - Flot is a pure Javascript plotting library for jQuery. It produces graphical plots of arbitrary datasets on-the-fly client-side. The focus is on simple usage (all settings are optional), attractive looks and interactive features like zooming

SAC - Simple accessible charts, An easy, fast and accessible way to display simple Data and beautify them with CSS. Works fine in FF, IE 7/6, Opera 9 tested on WIN XP

Similie - Timeplot is a DHTML-based AJAXy widget for plotting time series and overlay time-based events over them (with the same data formats that Timeline supports)

PlotKit - PlotKit is a Chart and Graph Plotting Library for Javascript. It has support for HTML Canvas and also SVG via Adobe SVG Viewer and native browser support

Libchart - Libchart is a free chart creation PHP library, that is easy to use

max函数的缺陷

2008-03-27T10:19:00.000+08:00

当使用enum或set类型时，order by是使用它们的内部整值来排序的，但是并不是所有的操作都是基于内部值得。max和min函数使用的是它们的字符串值来比较的，有点意外，不是吗？

查询返回的默认顺序

2008-03-05T18:07:00.000+08:00

按照sql标准，select如果不加order by子句，返回结果的顺序是不可靠的。

如果你希望保证顺序，必须要加上order by子句。

见下面的例子：

innodb的情况

test@127.0.0.1>CREATE TABLE t (
   ->   ID INT NOT NULL PRIMARY KEY,
   ->   PID INT,
   ->   FOREIGN KEY (PID) REFERENCES t(ID)
   -> ) ENGINE=INNODB;
Query OK, 0 rows affected (0.06 sec)

test@127.0.0.1>INSERT INTO t VALUES (1, NULL);
Query OK, 1 row affected (0.00 sec)

test@127.0.0.1>INSERT INTO t VALUES (2, NULL);
Query OK, 1 row affected (0.00 sec)

test@127.0.0.1>select * from t;
+----+------+
| ID | PID  |
+----+------+
|  1 | NULL |
|  2 | NULL |
+----+------+
2 rows in set (0.00 sec)

test@127.0.0.1>UPDATE t SET PID  = 2 WHERE ID = 1;
Query OK, 1 row affected (0.03 sec)
Rows matched: 1  Changed: 1  Warnings: 0

test@127.0.0.1>select * from t;
+----+------+
| ID | PID  |
+----+------+
|  2 | NULL |
|  1 |    2 |
+----+------+
2 rows in set (0.00 sec)

myisam的情况

test@127.0.0.1>create table t (a int primary key, b int) engine=myisam;
Query OK, 0 rows affected (0.00 sec)

test@127.0.0.1>insert into t values (1,2),(2,3),(3,4);
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

test@127.0.0.1>delete from t where a = 2;
Query OK, 1 row affected (0.00 sec)

test@127.0.0.1>insert into t values (4,5);
Query OK, 1 row affected (0.00 sec)

test@127.0.0.1>select * from t;
+---+------+
| a | b    |
+---+------+
| 1 |    2 |
| 4 |    5 |
| 3 |    4 |
+---+------+
3 rows in set (0.00 sec)

dev认证

2008-02-27T20:47:00.002+08:00

上月通过了MySQL的dev认证，果然还是寄来了个飞镖，只是从十字镖换成了三角镖。MySQL从2月18日起提高了中国的认证考试价格，一个认证从100美元跳到了400美元。质的飞跃啊！严重影响了我们的培训计划，送考试券促销完全不可行了。

information_schema的插件

2008-02-21T17:20:00.003+08:00

在MySQL5.1中可以自己编写information_schema的插件，用于得到一些服务器的内部信息，这里提供了一个简单的例子，是显示会话的savepoint的。虽然他说会增加显示临时表的插件，但我实在不想等了，于是也照葫芦画了一个。


mysql >create temporary table a (a int); create temporary table b (b int); select * from information_schema.mysql_temporary;
Query OK, 0 rows affected (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

+--------------------+----------------------+---------------------+
| TEMPORARY_TABLE_ID | TEMPORARY_TABLE_NAME | TEMPORARY_FILE_PATH |
+--------------------+----------------------+---------------------+
|                  1 | b                    | /tmp/#sql3ad0_1_1   |
|                  2 | a                    | /tmp/#sql3ad0_1_0   |
+--------------------+----------------------+---------------------+
2 rows in set (0.00 sec)

mysql_is_temporary.cc

不同语言使用MySQL的性能比较

2008-02-02T16:16:00.000+08:00

应某人要求比较了用C（gcc 3.4.6），Java（1.6），Perl（5.8），PHP（4）连接数据库并处理查询的性能。 C使用的是MySQL的C API，JAVA使用的是MySQL的Connector/J，Perl使用的是DBD::mysql，PHP使用的是mysql库。

比较了连接的速度，结果集很小的查询的速度（select 'a'）和结果集较大的查询的速度（select * from user limit 10000）。

服务器配置为1G内存，CPU为Intel Xeon CPU 3040@1.86GHz（双核），操作系统为Centos4.5。

测试结果

	C	Java	Perl	PHP
connect (s)	0.159	4.936	0.541	0.263
	0.186	4.933	0.540	0.262
	0.153	4.86	0.553	0.240
small resultset(s)	0.066	0.149	0.141	0.070
	0.066	0.155	0.147	0.071
	0.066	0.157	0.141	0.070
large resultset(s)	26.021	108.539	68.488	72.956
large resultset(s)	25.902	108.2	68.42	72.990
memory while large query(K)	1484	26684	5800	4960
vm while large query(K)	5380	216028	12744	14796
CPU while large query(%)	~94	~98	~91	～97

Perl不用变量绑定fetch的方式，而使用fetchall_arrayref()的时间为约83秒，如果使用fetchall_arrayref({})得到hash ref的数组，则所用时间为225秒。

测试程序


C：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "/usr/local/mysql/include/mysql.h"
/* gcc -c -I/usr/include C.c && gcc -o C C.o -lmysqlclient -lm -lz */
struct timeval tv;
MYSQL my_connection;
MYSQL_RES *res_ptr;
MYSQL_ROW sqlrow;
int res;

void conn(void);
void selectshort(void);
void selectlong(void);


int main(int argc,char *argv)
{
  gettimeofday(&tv, NULL);
  double t1_u = tv.tv_usec;
  double t1_s = tv.tv_sec;

  mysql_init(&my_connection);
  conn();

  int j=0;
  for(j=0;j<1000;j++)
 {
   selectlong();
 }
    
  mysql_close(&my_connection);

  gettimeofday(&tv, NULL);
  double t2_u = tv.tv_usec;
  double t2_s = tv.tv_sec;

  double t1= t1_s + (t1_u / 1000000);
  double t2= t2_s + (t2_u / 1000000);
  printf(" %f seconds used. \n", (t2-t1));
}

void conn()
{
  mysql_init(&my_connection);
  mysql_real_connect(&my_connection,"127.0.0.1","root","","test",0,NULL,CLIENT_FOUND_ROWS);
}

void selectshort()
{
  res = mysql_query(&my_connection, "select 'a'");
  if (res)
    {
   printf("SELECT error:%s\n",mysql_error(&my_connection));
    }
  res_ptr=mysql_store_result(&my_connection);
}

void selectlong()
{
  res = mysql_query(&my_connection, "select * from user limit 10000");
  if (res)
    {
   printf("SELECT error:%s\n",mysql_error(&my_connection));
    }
  res_ptr=mysql_store_result(&my_connection);
  if(res_ptr)
    {
   //printf("Retrieved %lu Rows\n",(unsigned long)mysql_num_rows(res_ptr));
   while((sqlrow=mysql_fetch_row(res_ptr)))
        {
    //printf("%s   %s   %s\n",sqlrow[0], sqlrow[1], sqlrow[2]);
        }
   if (mysql_errno(&my_connection))
        {
    fprintf(stderr,"Retrive error:%s\n",mysql_error(&my_connection));
        }
 }
  mysql_free_result(res_ptr);
}

Java：

import java.sql.*;

public class J {
    private static Connection conn;

    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
        } catch (Exception ex) {
            System.out.println(ex);
        }

        connect();
        long stime = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            selectlong();
        }
        long etime = System.currentTimeMillis();
        System.out.println("Jave used " + (etime - stime) / 1000.0
                + " seconds.");
    }

    private static void connect() {
        try {
            conn = DriverManager
                    .getConnection("jdbc:mysql://127.0.0.1/test?user=root&password=");

        } catch (SQLException ex) {
            System.out.println("SQLException: " + ex.getMessage());
            System.out.println("SQLState: " + ex.getSQLState());
            System.out.println("VendorError: " + ex.getErrorCode());
        }
    }

    private static void selectshort() {
        Statement stmt = null;
        ResultSet rs = null;

        try {
            stmt = conn.createStatement();
            rs = stmt.executeQuery("SELECT 'a'");
            // while (rs.next()) {
            // rs.getString(1);
            // }
        } catch (Exception ex) {
            System.out.println(ex);
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException sqlEx) {
                }
                rs = null;
            }
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException sqlEx) {
                }
                stmt = null;
            }
        }
    }

    private static void selectlong() {
        Statement stmt = null;
        ResultSet rs = null;

        try {
            stmt = conn.createStatement();
            rs = stmt.executeQuery("SELECT * from user limit 10000");
            int id, age;
            String name, email, address;
            Timestamp createTime;
            while (rs.next()) {
                id = rs.getInt(1);
                name = rs.getString(2);
                email = rs.getString(3);
                address = rs.getString(4);
                age = rs.getInt(5);
                createTime = rs.getTimestamp(6);
                // System.err.printf("%3d %-20s%-20s%-30s%3d\n", id, name,
                // email, address, age);
            }
        } catch (Exception ex) {
            System.out.println(ex);
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException sqlEx) {
                }
                rs = null;
            }
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException sqlEx) {
                }
                stmt = null;
            }
        }

    }
}

Perl：

use DBI;
use Time::HiRes qw/gettimeofday tv_interval/;

our $dbh;
my $stime = [gettimeofday];

conn();
for($i = 0; $i < 1000; $i++) {
    selectlong();
}

my $elapsed = tv_interval($stime);
print "Perl used $elapsed seconds.\n";

sub conn {
    $dbh = DBI->connect("dbi:mysql:host=127.0.0.1;database=test","root") or die "Can not connect.";
}

sub selectshort {
    my $sth = $dbh->prepare("select 'a'");
    $sth->execute();
#    my $re = $sth->fetchall_arrayref();
#    print $re->[0][0],"\n";
}

sub selectlong {
    my $sth = $dbh->prepare("select * from user limit 10000");
    $sth->execute();
    my ($id, $name, $email, $address, $age, $create_time);
    $sth->bind_columns(\$id, \$name, \$email, \$address, \$age, \$create_time);
    while($sth->fetch){
#        printf(STDERR "%3d %-20s%-20s%-30s%3d\n",$id, $name, $email, $address, $age);
    }
}

sub selectlong2 {
    my $sth = $dbh->prepare("select * from user limit 10000");
    $sth->execute();
    my $re = $sth->fetchall_arrayref();
}

PHP：

<?php 
$dbh=null; 
$time_start = microtime_float(); 
conn();
for ($i = 0; $i < 1000; ++$i) { 
    selectlong();
} 
$time_end = microtime_float(); 
echo "PHP used ", $time_end - $time_start, " seconds\n"; 
 
function conn() { 
    global $dbh; 
    $dbh = mysql_connect("127.0.0.1", "root") or die("Can not connect."); 
    mysql_select_db("test", $dbh) or die("Can not connect."); 
} 
 
function selectshort() { 
    global $dbh; 
    $re = mysql_query("select 'a'", $dbh); 
#    $row = mysql_fetch_array($re); 
#    echo $row[0], "\n"; 
} 
 
function selectlong() { 
    global $dbh; 
    $re = mysql_query("SELECT * from user limit 10000", $dbh); 
    while ($row = mysql_fetch_array($re)) { 
    } 
} 

function microtime_float(){ 
    list($usec, $sec) = explode(" ", microtime());
    return ((float)$usec + (float)$sec);
}
?>

drbd性能测试

2008-01-29T16:15:00.000+08:00

一直想做drbd的性能测试，但一直没有时间，其中等买千兆的网线还等了一个星期。拖拖拉拉弄了一个多月，终于有了结果。

使用的drbd版本是0.7.24。
拷贝一个612M的目录，所需时间如下：

_from^to	normal	drbd
normal	25s	33s
drbd	28s	38s

拷贝10000个16K的文件

_from^to	normal	drbd
normal	1.2s	3.5s
drbd	2.2s	3.4s

使用load data向数据库中导入500000条数据，文件大小为44M，单位秒。

	innodb			myisam
drbd	10.24	11.37	9.26	5.43	5.53	5.32
normal	9.24	9.90	8.27	5.24	5.22	5.27

可以看到时间多了10%左右。

explain的extended选项

2008-01-17T13:14:00.000+08:00

MySQL的explain命令有一个extended选项，我想可以很多人都没有注意，因为它对命令的输出结果没有任何改变，只是增加了一个warning。这个warning中显示了MySQL对SQL的解释，从这个解释中我们可以看到SQL的执行方式，对于分析SQL还是很有用的。

比如：


mysql>explain extended select * from t where a in (select b from i);
+----+--------------------+-------+------+
| id | select_type        | table | type |
+----+--------------------+-------+------+
|  1 | PRIMARY            | t     | ALL  |
|  2 | DEPENDENT SUBQUERY | i     | ALL  |
+----+--------------------+-------+------+
2 rows in set, 1 warning (0.01 sec)

子查询看起来和外部的查询没有任何关系，为什么MySQL显示的是DEPENDENT SUBQUERY，和外部相关的查询呢？从explain extended的结果我们就可以看出原因了。


mysql>show warnings\G
*************************** 1. row ***************************
Level: Note
Code: 1003
Message: select `test`.`t`.`a` AS `a`,`test`.`t`.`b` AS `b`,`test`.`t`.`c` AS `c`
from `test`.`t` where
<in_optimizer>(`test`.`t`.`a`,
<exists>(select 1 AS `Not_used` from `test`.`i`
where (<cache>(`test`.`t`.`a`) = `test`.`i`.`b`)))
1 row in set (0.00 sec)

在这里MySQL改写了SQL，做了in的优化。

用连接改写子查询

2008-01-17T13:03:00.001+08:00

由于在MySQL中对子查询的优化不如连接，所以通常连接的速度会比子查询快，我们可以通过把子查询改写成连接来优化查询。

改写的方法可以见：http://dev.mysql.com/doc/refman/4.1/en/rewriting-subqueries.html
因为5.0开始支持子查询，所以这一节在新的手册中被删除了，必须要看4.1的手册。

soliddb

2008-01-04T15:41:00.000+08:00

soliddb是一个第三方的MySQL存储引擎，看到它网站上的测试报告说soliddb的数据扩展性，CPU扩展性和事务响应时间都比innodb强。于是自己下载了做了一些测试，也希望以后能用。结果发现结果很不好，批量插入的速度是innodb的一半，一个简单的select count(*)也比innodb慢一倍。大致看了一遍手册，觉得性能相关的参数主要就是soliddb_durability_level和soliddb_cache_size。soliddb_durability_level设为1和3插入的时间好像没有什么变化，soliddb_cache_size设为500M，应该足够了。

MySQL的字符集错误

2007-12-19T10:00:00.001+08:00

在使用字符集的时候有三个部分：

1. 服务器上使用的字符集，是我们在表定义时使用 default charset 指定的字符集

2. 连接使用的字符集，一般用 set names 指定

3. 客户端使用的字符集，插入记录时记录的字符集

如果不在乎汉字在数据库中怎么保存，那么只需要保证1，2一致，然后写入和读取的3都一样，在使用时就不会有乱码了，即使在数据库中保存的内容实际和指定的字符集不一样。这就是为什么默认都使用latin1的编码，但应用程序中不会出现问题。如果这时1和2不一样，MySQL会自动转码，可能会因为1的编码范围没有包含汉字的编码而导致乱码。

如果希望数据库中的内容和指定的字符集一致，那么1中就要设成gbk或utf8以保证符合汉字的编码范围。然后2，3的字符集始终要保持一致，但写入和读出时使用的字符集可以不同。比如：
表定义中使用gbk

CREATE TABLE `aa` (
`a` varchar(20) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=gbk

插入记录时使用utf8，MySQL会自动把utf8的字符转成gbk的字符后插入数据库。为了使插入记录是utf8编码的，这时需要把 term 的编码设成utf8。使用putty的话，在 change settings/Translation 中更改。

mysql> set names utf8;
mysql> insert into aa values ('你好');

然后当读出的时候，可是仍使用utf8，或者使用gbk：

mysql> set names gbk;
mysql> select * from aa;
+------+
| a    |
+------+
| 你好     |
+------+
1 rows in set (0.00 sec)

MySQL会以gbk输出内容，这时需要把 term 的编码改成gbk以正常显示。putty 中可以把显示字体改为中文字体，然后选择编码为 Use font encoding，以显示gbk的编码。

如果在插入是2，3使用的字符集不一致，那么正常读取的时候就会出现乱码。比如现在 term 的编码是utf8。


mysql >set names gbk;
Query OK, 0 rows affected (0.00 sec)

mysql>insert into aa values ('明天');
Query OK, 1 row affected (0.00 sec)

mysql>set names utf8;
Query OK, 0 rows affected (0.00 sec)

mysql>select * from aa;
+-----------+
| a         |
+-----------+
| 你好      |
| 鏄庡ぉ    |
+-----------+
2 rows in set (0.01 sec)

这时aa中的第二条记录在数据库中保存的是"明天"的utf8编码，所以如果用 set names utf8，MySQL在读取时会做一次gbk到utf8的转换导致乱码。如果 set names gbk，那么MySQL不会做编码转换，需要保存 term 的编码为utf8才能正常显示第二条记录，但第一条又会变成乱码：

mysql >select * from aa;
+--------+
| a      |
+--------+
| ▒▒▒       |
| 明天   |
+--------+
2 rows in set (0.00 sec)

我们可以使用下面的语句纠正编码


mysql >set names utf8;
Query OK, 0 rows affected (0.00 sec)

mysql >update aa set a = convert(convert(a using binary) using utf8) where a <> '你好';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql >select * from aa;
+--------+
| a      |
+--------+
| 你好   |
| 明天   |
+--------+
2 rows in set (0.00 sec)

同样的，如果原来使用的编码一直是latin1，之后想转成utf8，可以按照如下步骤：

create table x (a varchar(10)) character set latin1;
set names latin1;
insert into x values ('你好');
set names utf8;
alter table x modify a varchar(10) character set utf8;
update x set a = convert(convert(convert(a using latin1) using binary) using utf8);

在MySQL中使用memcached

2007-12-14T17:19:00.000+08:00

这里提供了一组MySQL的UDF函数，可以直接在SQL中操作memcached。安装比较简单，需要安装libmemcached-0.12.tar.gz，然后安装memcached_functions_mysql-0.1.tar.gz就可以了。它的帮助文件中提供了使用方法。只是需要设置LD_LIBRARY_PATH，重启MySQL后，在定义函数时才能找到对应的so文件。


test@127.0.0.1>select memc_set(2,10009);
+-------------------+
| memc_set(2,10009) |
+-------------------+
|                 0 |
+-------------------+
1 row in set (0.00 sec)

test@127.0.0.1>select memc_get(2);
+-------------+
| memc_get(2) |
+-------------+
| 10009       |
+-------------+
1 row in set (0.00 sec)

test@127.0.0.1>select benchmark(100000,memc_get(2));
+-------------------------------+
| benchmark(100000,memc_get(2)) |
+-------------------------------+
|                             0 |
+-------------------------------+
1 row in set (2.68 sec)

速度也还不错，perl读10000次需要2.x秒，这个快了不少。
这样的话，如果有什么东西需要缓存到memcached中，那么可以直接用trigger实现缓存的插入和更新操作，写程序应该会方便很多。

MySQL认证

2007-12-03T08:46:00.000+08:00

通过了MySQL的DBA认证，还是挺容易的。今天证书终于寄到了，比较搞笑的是，居然还寄来了一个玩具十字镖。是建议DBA多多放松吗？

EverNote限时免费

2007-11-15T16:53:00.000+08:00

evernote是一个记笔记的软件，看了不少它的介绍，感觉还不错了，除了对中文的支持还不算完美。原价$49.95，但今天是免费的。
http://www.giveawayoftheday.com/evernote/

为输出添加颜色

2007-11-11T00:26:00.000+08:00

$str = "TAKE CARE";
if(-t STDOUT){
  print "\e[1;31m$str\e[0m\n";
} else {
  print "$str\n";
}

-t 是判断输出是不是tty，如果是的则输出颜色信息，如果不是，比如在STDOUT被重定向到文件时则不加颜色信息。

把中文按读音转成字母

2007-11-03T19:19:00.000+08:00

因为在url中使用中文有时候会很麻烦，今天就遇到了。所以会想把中文转成拼音，这样就不会出现问题了，就像很多blog的程序生成文章的链接时会只取标题中的英文。很久以前就看到过这样一个模块，就是想不起来名字了，在CPAN找到半天，终于还是找到了：Text::Unidecode。


use utf8;
use Text::Unidecode;
print unidecode("你好");

# That prints: Ni Hao

虽然还有一些把汉字转成拼音的模块，也有比这个转得更好的，甚至还有声调，但这个强在日韩通吃（不过我没试过其他的到底支不支持日文和韩文）。

使用Devel::Size查看变量占用内存

2007-10-18T12:09:00.000+08:00

在“mastering perl”上看到一个有用的模块：Devel::Size。可以用来查看变量的大小，以后不用靠free来猜到底用了多少内存了。

Nerd

2007-10-17T18:17:00.000+08:00

使用XML::Parser的乱码问题

2007-10-10T18:39:00.000+08:00

目前使用XML::Parser解析XML文件的时候，它会把读入的字符设成utf8的（perl内部的utf8 flag设成on），可能导致之后的处理中出现乱码。可以把读出的字符用_utf8_off或encode转一遍去掉utf8 flag以解决乱码问题。

批量update

2007-10-10T11:08:00.000+08:00

我们都知道在MySQL中批量insert的速度会比一条条insert快很多。类似的，update也应该是如此，但因为update的值往往因为条件的不同而不同，只能分开做。
但是在下面的情况下，批量的update是可以做到的。
1. 查询的条件中有主键或唯一键
2. 查询的条件是等于，而不是范围。这实际上包含了1的情况

在1的情况下，可以使用
replace 或者 insert into ... values ... on duplicate key update ...
两者都是在键重复的情况下自动的做更新，但需要注意的是，键不存在的时候会做insert操作。

在2的情况下，可以建一张临时表，把要更新的值插入临时表，然后和需要更新的表连接做update
如:


+-------------+------------------+------+-----+-------------------+
| Field       | Type             | Null | Key | Default           |
+-------------+------------------+------+-----+-------------------+
| id          | int(11)          | NO   | PRI | NULL              |
| name        | varchar(30)      | YES  |     | NULL              |
| email       | varchar(40)      | YES  |     | NULL              |
| address     | varchar(50)      | YES  |     | NULL              |
| age         | int(10) unsigned | YES  |     | NULL              |
| regist_time | timestamp        | NO   |     | CURRENT_TIMESTAMP |
+-------------+------------------+------+-----+-------------------+

要按照id更新name
两种方法分别为


insert into user (id,name) values (?,?),(?,?) on duplicate key update name = values(name)


create temporary table tmp (id int primary key, n varchar(20));
insert into tmp values (?,?),(?,?);
update user, tmp set user.name = tmp.n where user.id = tmp.id;

这样当user的数据量是10万，更新2万的时候，包括必要的程序时间，一条条更新需要1.7秒，方法1需要0.30秒，方法2需要0.26秒。

DBI

2007-10-02T11:50:00.000+08:00

程序中一直用DBI的绑定，但是发现DBI做绑定的时候不管参数是数字还是字符都会当成字符，至少在MySQL中是如此。比如，age = ?，绑定20时，实际上的查询会是 age = '20'。因此MySQL在执行时需要做字符到数字的转换，对性能有一定的影响。
如，

select count(*) from user ignore key (age) where age = '45'

的查询时间为0.50秒，而

select count(*) from user ignore key (age) where age = 45

只需要0.41秒，其中user中有100万数据。
查看了一下DBI的文档，没有看到什么地方可以设置。
不过发现了一些以前不曾用到的DBI的功能，不知道是一直没注意还是新版加的，DBI的更新还是挺频繁的。
比如可以设置dbh的Profile属性，设置之后执行完会多一条时间的显示：

DBI::Profile: 0.005288s (4 calls) test.pl @ 2007-10-02 12:01:09

另外还有TraceLevel属性，可以跟踪打印执行的sql。
还有很多以前没用过的方法，过完节可以找人研究一下。

Commit database

2007-09-20T09:01:00.000+08:00

在“Building Scalable Web Sites”这本书里看到一个概念：commit database。指用数据库记录版本控制系统的提交信息，以方便查询。对于SVN，有Kamikaze (http://kamikaze-qscm.tigris.org/)，它是用脚本将commit信息记录到MySQL中。目前还没有觉得有多大的用处，先记下来。

innodb_support_xa

2007-09-14T10:58:00.000+08:00

按文档上说支持XA的事务提交分成两步，会有两次写操作。这个选项默认是开的，如果没有用到XA事务，则可以关闭以提高性能。因为只是和提交有关，所以如果事务都比较大，那么性能改善不明显，如果事务较小，或者使用了autocommit，那么从测试的结果看性能能提高10%左右。
另外还有一个选项innodb_flush_method，改成O_DIRECT在centos4.4上看不到明显效果，不过文档说这是和系统相关的，所以如果是其他的系统也可以试一试，但有性能下降的可能。

read_rnd_buffer和sort_buffer

2007-09-13T11:07:00.000+08:00

做了一个对这两个参数的测试。表有100万行，每行100左右。
select * from test_table order by a;
改sort_buffer_size的效果比较明显，改成256k时需要2分10秒，而是32M的时候只需要24秒。
read_rnd_buffer是在使用行指针排序之后，随机读用的。
把max_length_for_sort_data改成64，使得排序时不会读入整行，只用行指针排序，排序的时间缩短为7秒。但这时表实际上已经在内存中了，read_rnd_buffer应该没有起到多大的作用，修改之后时间都差不多。如果表的内容不在内存里，从硬盘读，就需要100万次随机读，等了将近10分钟，没有出来，于是放弃了。我想read_rnd_buffer_size可能能把1个小时的时间缩短成半个小时，但最终结果对于web运用仍然是不可接受的。因此read_rnd_buffer_size不需要设成很大的值。
还有一个read_buffer，据说目前只是MyISAM表用到，直接改变量的值看不出明显的效果。MyISAM的表的内容是缓存在系统cache中的，除了重启不知道有什么办法清除，所以没有做更多的测试。

取分组中的特定记录

2007-09-11T15:08:00.000+08:00

表test有三列(a,b,c)，100万条记录。(a,b)上有唯一索引，现在要查找对于每一个a，b的值最大的那条记录。有好几种方法。

1. select * from (select * from test order by d desc) as t group by a;
速度最快的，但只有MySQL可以用。

2. select t1.* from test t1 left join test t2 on t1.a = t2.a and t1.b < t2.b where t2.b is null; 因为用了联接，查询的行数比较多，所以比较慢。a的选择率越低，速度越慢。

3. select * from test where (a,b) in (select a,max(b) from test group by a); 这个慢不是因为表扫描，而是因为对于test的每一行，select a,max(b) from test group by a都会做一遍，这个从profile的结果可以看出来，explain中select_type是DEPENDENT SUBQUERY应该是同样的意思。

所以先建一个临时表可以提高速度，
select t1.* from test t1 , (select a,max(b) as b from test group by a) as t2 where t1.a = t2.a and t1.b = t2.b

这种方法，a的选择性越高则越慢

4. select * from test t1 where not exists (select * from test t2 where t1.a = t2.a and t1.b < t2.b)
和2差不多

MySQL的 select 和 sort 变量

2007-09-05T11:22:00.001+08:00

总是会忘记 status 中 Select% 的那几个变量的具体含义，这次干脆写下来以便日后查询。
主要有这9个变量。
1. Select_scan
2. Select_range
3. Select_full_join
4. Select_range_check
5. Select_full_range_join
6. Sort_scan
7. Sort_range
8. Sort_merge_passes
9. Sort_rows
其中 Select_scan 和 Select_range 包括了单表查询和多表联接查询中的第一个表。Select_full_join, Select_range_check 和 Select_full_range_join 用于多表联接查询中的第二张及之后的表。Sort 的那几个变量则用于任何需要排序的查询。

Select_scan
代表了需要做全表扫描。在 explain 中 type 会显示为 ALL，原因是查询没有能用到索引。因为全表扫描一般比较慢，所以应该尽量避免。

Select_range
代表需要从硬盘读表在一段范围内的行。在 explain 中显示为 range，说明使用了索引查找记录在硬盘上的位置。

Select_full_join
和 Select_scan 差不多，区别是 Select_full_join 代表的是第二张及之后的表。explain 中的类型也是 ALL，原因是表联接所用的字段上没有索引。它对性能有更为严重的影响，绝对要避免，所以用于联接的字段上一般都要加索引。

Select_range_check
这个比 Select_full_join 要好一点，和 Select_range 差不多。区别是 MySQL 不能确定它是否能否使用一个范围来做联接。如果可以那么会使用范围，如果不行仍会使用全表扫描。在 explain 中 type 也会是 ALL，但 extra 中会有 Range checked for each record (index map: ) 的说明。不能肯定是否能用范围是因为联接是条件不确定。如：
SELECT * FROM tbl1, tbl2 WHERE tbl1.col1 > tbl2.col1
如果 tbl2.col1 上有索引，那么可以做 Select_range_check，explain的结果如下

   mysql> EXPLAIN SELECT * FROM tbl1, tbl2 WHERE tbl1.col1 > tbl2.col1;
  +-------------+-------+------+---------------+------+---------+------+------+------------------------------------------------+
  | select_type | table | type | possible_keys | key  | key_len | ref  | rows | Extra                                          |
  +-------------+-------+------+---------------+------+---------+------+------+------------------------------------------------+
  | SIMPLE      | tbl1  | ALL  | NULL          | NULL | NULL    | NULL |   27 |                                                |
  | SIMPLE      | tbl2  | ALL  | col1          | NULL | NULL    | NULL |   18 | Range checked for each record (index map: 0x1) |
  +-------------+-------+------+---------------+------+---------+------+------+------------------------------------------------+

如果链接 tbl2 的时候 MySQL 判断可以使用范围查找，它仍然会增加 Select_range_check 而不是 Select_range。

Select_full_range_join
和 Select_range_check 类似，不过 MySQL 可以肯定它能够使用范围查找。这时 explain 中的类型是 range。这也可能是有一些性能问题的。

Sort_scan 和 Sort_range
查询做排序，不论是因为 order by 还是 group by（除了使用了 order by NULL 的 group by），主要都是下面的三步：
1. 通过 where 条件找到记录
2. 排序
3. 按排好的顺序读取记录
如果第二步不被跳过，那么第三步中就会有 Sort_scan 或 Sort_range。如果第一步是 Select_scan，那么第三步将是 Sort_scan，如果第一步是 Select_range，那么第三步会是 Sort_range。但 Sort_scan 和 Sort_range 其实没有功能上的区别，都是将需要的记录按顺序读出来，所以性能也是一样的。

Sort_merge_passes
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 ?

Sort_row
这代表了在第二步中被排序的记录的总数。因为 Sort_range 和 Sort_scan 是一样的，所以这个值只是说明了有多少记录被排序，意思不大。

mysqltoolkit

2007-09-01T22:26:00.000+08:00

mysqltoolkit是一组MySQL的命令行工具。
包括11个小工具。

MySQL Visual Explain
提供sql的树状explain结果，看得比较清楚。不过我觉得对于我来说用处不大，MySQL自己的结果我已经看得很习惯了。可能对初学者比较友好吧。
MySQL Query Profiler
执行一系列sql，并显示status中的变化。分析sql的时候比较有用。
MySQL Show Grants
将权限信息导出成sql。
MySQL Find
根据行数，字段大小等很多条件找表，算是个有趣的工具吧。不过现在表最多也只有1000个左右，还有很多结构类似的，暂时还不需要用程序找。
MySQL Duplicate Key Checker
检查重复的索引。
简单的用了一下上面这几个。算不上很有用处的工具吧，不过当然比没有强。

下面这些还没有机会试。
MySQL Archiver
表存档。
MySQL Deadlock Logger
可以记录死锁。
MySQL Slave Restart
监视slave，如果出问题了，可以设置忽略某些错误自动重启。
MySQL Slave Delay
保持slave有一定的延迟，让delete语句有反悔的机会吗？暂时没想到有什么用处。
MySQL Table Checksum
检查表的数据是否一致。
MySQL Table Sync
表同步，可以用于replication同步。replication数据不一致的时候，同步一下就好了，不用重建，也不需要很麻烦的对日志文件了。不过系统用了lvm之后，重建replication太简单了，搞得只要有问题就重建。

group by是否应该使用索引

2007-08-28T18:51:00.000+08:00

在MySQL的论坛上看到有人说“ Index slows down SELECT ... GROUP BY query”，追究下来才知道做group by有时不要索引更好。MySQL为此在5.0.40和5.1.17中追加了新的语法。

5.0.40 ignore key for join (idxname)
5.1.17 ignore key for join |order by | group by(idxname)

如果没有指定for语句，则是所有的情况都忽略索引。
而使用索引变慢的原因是，做统计的列不在索引中，所以需要通过索引读每一行，这样行数多的时候会产生很多的随机读，其速度还不如按顺序读整表之后再group。

原来show status也可以用where的

2007-08-20T08:31:00.000+08:00

看到文档上只说show statue like，一直以为只能用like，于是看两个变量名差得比较远的就很不方便了。今天看到有人说用where也可以，果然如此，为什么自己没有试一试呢。写法如下：
show global status where variable_name like "com_%";

db字段过长

2007-07-31T14:52:00.000+08:00

DBI报错

Data in column 5 has been truncated to 32700 bytes. A maximum of 37556 bytes are available at /usr/lib/perl5/site_perl/5.8.5/i386-linux-thread-multi/DBI.pm line 1981

原因是字段太长了被截断了，可以在db连接的参数中加入LongReadLen指定最大的长度。如:
DBI->connect('xxx','root','',{LongReadLen => 8 * 1024 * 1024})

神奇

2007-06-25T17:32:00.000+08:00

网上下了一个digg的幻灯片，因为用的是openoffice的格式，机器上没有装，又懒得去下载了。搜到sharepoint可以播放这种格式的，就注册了个用户上传上去了。没想到就开始一直收到sharepoint的邮件通知说幻灯被人收藏了，随后还在delicious的hotlist中看到。看来sharepoint的访问量应该挺大，或许可以利用它来增加流量。

日本

2007-06-23T17:04:00.000+08:00

又来到日本了，最高兴的应该是没有某盾的阻挠，又可以直接访问blogspot了。

mysql 字符集

2007-06-13T10:50:00.000+08:00

mysql在建表的时候可以指定字符集和校对规则。校对规则有三种形式的结尾，_ci 代表了大小写不敏感，_cs是大小写敏感，_bin是二进制，也是大小写敏感的。
默认的校对规则是大小写不敏感的，所以如何我们建了这样一张表：

create table t (n varchar(10)) default charset=latin1;
insert into t values('w'), ('W');

然后查询

select * from t where n = 'w';

将会返回两条记录。
如果我们需要大小写敏感的查询，可以临时改变其校对规则：

select * from t where n collate latin1_general_cs = 'w';

这样将只有一条记录返回，但是如果n上有索引，那么索引通常是不能被使用的。
另外mysql中char和varchar末尾的空格会被忽略，

select * from t where n = 'w   ';

同样会返回两条结果，所以如果n上有unique index，那么只有末尾空格数有差别的两条记录会被认为是重复的。
如果希望比较末尾的空格，需要使用

select * from t where binary n = 'w  ';

同样这种形式也不能用到索引。
如果确实需要区别末尾的空格，可以使用varbinary类型，它是保存二进制的字符串，比较时也使用二进制，没有校对规则。
如

alter table t modify n varbinary(10);

32位系统的最大内存

2007-06-04T08:15:00.000+08:00

mysql遇到内存不足的问题，但实际上内存并没有用完。所以做了一些调查，道听途说而已，可能结果并不是很准确。32位的linux只支持最大4G内存，而4G的内存一般情况下是分1G为系统空间，3G为用户空间，用户的程序只能在用户空间中分配内存，也可能用到系统空间，但不是自己分配的。因此一般单进程最大能分配3G内存。可以使用下面的程序测试一下：

#include <stdio.h>
#include <stdlib.h>
int main(){
  int MB = 0;
  while(malloc(1 << 20)) ++MB;
  printf("Allocated %d MB total.\n", MB);
}

MONyog 又一个mysql监视工具

2007-05-26T10:24:00.000+08:00

MONyog MySQL Monitor and Advisor：
在本机装客户端监视mysql，基于网页的，安装完了会开一个本地的web服务。
可以监视多个服务器，并且针对各种配置有一些优化的意见。网页主要基于js，似乎还可以自己修改。

另外这里还提供一个mysql gui的工具。有企业版和免费版。用着跟mysql query browser差不多，不过感觉比qb好一点，主要是前一阵子用qb总是做了几个查询之后就使用内存太多爆掉了，之后一直在使用mysql的命令行，这个也算是一个gui的代替品吧。

HotSaNIC的MySQL监视模块

2007-05-16T13:08:00.000+08:00

写了一个hotsanic的mysql module。目前有5个项目：cache，connection，query/s，slow queries和innodb buffer pool。
点这里下载。
使用比较简单，下载后运行下面的命令，运行前更改命令中相关的部分，最好为mysql建一个专门的监视用户，如 grant usage on *.* to watcher@'127.0.0.1' identified by 'xxxxx'。


cd /usr/local/HotSaNIC/modules/
tar zxvf /tmp/module_mysql.tar.gz
cd mysql
sed -i "/PASSWORD/cPASSWORD=\"XXXXXXX\"" settings
cd ../../
sed -i -e "/^RUN/s/=\"/=\"mysql /" -e "/^SHOW/s/=\"/=\"mysql /" settings
./rrdgraph restart
./makeindex.pl && ./diagrams.pl && ./convert.pl

就只做了目前觉得需要的，其他的项目以后有需要了再加。
例:

加快MySQL关闭速度

2007-05-10T17:01:00.001+08:00

InnoDB的buffer pool中可能有很多unflushed的数据，使得关闭MySQL很慢。如果需要加快关闭的速度，可以设置
set global innodb_max_dirty_pages_pct=0
然后通过show status看InnoDB_buffer_pool_pages_dirty。当它接近于0时再关MySQL。

设置swap

2007-05-08T12:55:00.000+08:00

linux系统会用内存做很多的buffer和cache，所以经常会看到内存用完了，其实这里面可能只有很少的一部分是程序用到的。当内存不足的时候，系统有两种选择，一是减少缓存的量，另一种是把部分程序使用的内存换到swap中。如果是mysql使用的内存被转移到swap中了会对性能有很大的影响，所以应该尽量保持 mysql使用的部分在内存中不被转移出去。可以使用memlock启动mysql是mysqld保持在内存中，不过使用这个选项需要以 root运行服务器。还可以使用关闭swap，可以使用swapoff或者umount分区，不过当内存不够大的时候（比如只有1G）系统不太稳定，可能会导致mysql内存不足出错。也可以设置系统变量vm.swappiness，修改 /etc/sysctl.conf 添加 vm.swappiness = 0，并执行 sysctl -p 或 sysctl -w vm.swappiness=0。这个变量的范围是0至100，默认值60，当内存不足时，此变量的值小则系统偏向于减少缓存，反之则转移程序内存到 swap。但即使将它设为0了，系统仍然有可能使用swap。

MySQL的备份与恢复

2007-04-25T15:13:00.000+08:00

备份
备份分为完全备份和增量备份。
完全备份有两种方式，一种是备份所有的数据库文件，适合比较大的数据库，另一种是将数据库全部dump出来，适合数据比较少的情况。
对于第一种方法，各种引擎的方式差不多，步骤如下：
1. flush tables with read lock 加读锁保持数据的一致性
2. flush logs或者show master status记下二进制日志的位置方便增量备份
3. 建立快照或者直接拷贝数据库文件
4. unlock tables
3中如果建立快照还需要下面两步：
5. 拷贝数据库文件
6. 删除快照
对于MyISAM表还可以使用mysqlhotcopy，它也是直接拷贝表文件。由于脚本自己会锁表所以步骤比较少，命令为：
mysqlhotcopy -h hostname -u username --flushlog db_name /bak/path
需要注意的是mysqlhotcopy（5.0.37）和最新的DBI（1.54）不兼容，可以在842行后加上一行
s/.*$quote//g;
解决。
注意用这种方法，如果不是用快照，那么当数据库很大的时候，锁表的时间比较长，这段时间内更新操作不能进行。

对于第二种方法，可以使用mysqldump，当然也可以用select into，不过用这个命令比较麻烦。
如果是innodb的表，那么使用参数--single-transaction可以保持数据库的一致性，而锁表的时间很短。
如果不是innodb表，那么就要使用--lock-tables或者--lock-all-tables，这样在整个导出过程中加读锁，期间更新操作不能进行，当数据库比较大的时候需要注意。--lock-tables是按数据库加锁，不能保证全部数据库的一致性，--lock-all-tables是给所有数据库的所有表加锁。
命令为：
mysqldump --lock-all-tables --flush-logs --master-data=2 --all-database > db.sql
或
mysqldump --single-transaction --flush-logs --master-data=2 --database db_name> db.sql

增量备份则是定期备份二进制日志，备份前使用 flush logs 刷新日志。如果之前完全备份使用了flush命令或选项，那么增加备份从完全备份之后新生成的日志开始，否则从完全备份时在使用的日志开始。

恢复
恢复步骤比较简单。
1. 如果是备份的数据文件，那么拷回数据目录。如果是导出的，用 mysql < bak.sql 导入
2. 导入完全备份之后增量备份的二进制日志，命令为 mysqlbinlog mysql-bin.xxxx | mysql。
如果完全备份时没有刷新日志可能还需要用--start-datetime或--start-position指定日志的起始位置。

[zz] MySQL使用tips

2007-04-20T13:49:00.001+08:00

用mysql内置函数转换ip地址和数字
利用两个内置函数
inet_aton:将ip地址转换成数字型
inet_ntoa:将数字型转换成ip地址
充分利用mysql内置的format函数
尤其是在处理字符格式的时候,例如将12345转换成12,345这样的,只要用:format(12345,0)即可,如果用format(12345,2)则显示的是12,345.00了...
利用mysql的内置函数处理时间戳问题
eg : select FROM_UNIXTIME(UNIX_TIMESTAMP(),'%Y %D %M %h:%i:%s %x');
结果: 2004 3rd August 03:35:48 2004
利用mysql_convert_table_format转换表类型
需要DBI和DBD的mysql相关模块支持才能用,例子:
mysql_convert_table_format --user=root --password='xx' --type=myisam test yejr
修改mysql表中的字段名
alter table tb_name change old_col new_col definition...
利用临时变量
select @var1:=a1+a2 as a_sum,@var2:=b1+b2 as b_sum,@var1+@var2 as total_sum from test_table xxx;
用int类型存储ip地址
原先错误的认为必须用bigint才够，后来发现使用int unsigned类型就足够了。 :)
利用IF函数快速修改ENUM字段值
一个例子：
update rule set enable = if('0' = enable,'1','0') where xxx;
enable 类型：enum('0','1') not null default '0'
事务无法嵌套
避免长时间的sleep连接造成的连接数超出问题
设定全局变量 wait_timeout 和 interactive_timeout 为比较小的值，例如
10(s)，就能使每个sleep连接在10s之后如果还没有查询的话自动断开。
设定mysql客户端的提示符(prompt)
export MYSQL_PS1="(\\u:\\h:)\\d> "
则用 mysql -hlocalhost -uroot -pxx db_name 登录后，提示符变成：
(root:localhost:)db_name>
好用吧 :), 时时刻刻提醒你在哪个服务器上，尽量避免误操作的发生
更详细的请查看MySQL手册
整理MyISAM碎片
1.) 定期运行 OPTIMIZE TABLE 命令即可
2.) 用mysqldump出数据，然后重新import回去，这对大表来说显然第一种方法比较方便
整理Innodb碎片
1.) 运行NULL命令， ALTER TABLE XXX ENGINE=Innodb;
2.) 同上的mysqldump方法
MySQL如果认为检索的记录数量超过总记录数的30%，则选择全表扫描，而非使用索引
MySQL 5.0.3之后,VARCHAR字段后面的空格就不再删除。但查询时是忽略末尾空格的。
MySQL 4.1之后，MySQL把字符串类型字段的长度定义理解为字符长度而不是字节长度
MySQL 4.1=>5.0时，增加了一个新的启动选项 innodb_table_locks，它导致 LOCK TABLE 时也可以请求 InnoDB
表锁。这个选项默认打开，不过可能在 AUTOCOMMIT=1 和 LOCK TABLES 应用中会导致死锁
5.0.3开始，在计算 DECIMAL 值和舍入精确值的时候采用精确数学，DECIMAL 用更有效的格式来存储
从5.0.12开始，自然连接和使用 USING
的连接，包括外部连接的衍生形式，都按照SQL:2003标准来处理了；这个变化导致减少了自然连接和使用 USING
的连接产生的结果字段数，并且还将按照更合理的顺序显示这些字段，逗号比较符的优先顺序和 JOIN, LEFT JOIN 中的一样了
在以前，等待超时的锁会导致 InnoDB 回滚当前全部事务，从5.0.13开始，就只回滚最近的SQL语句了
InnoDB 和 MyISAM 表中空格结尾的 TEXT 字段索引顺序改变了。因此需要运行 "CHECK TABLE" 语句修复数据表，如果出现错误，就运行
"OPTIMIZE TABLE" 或 "REPAIR TABLE" 语句修复，甚至重新转储(用mysqldump)
MySQL 5.0.3到5.0.5之间版本的 MyISAM 和 InnoDB 表中创建的 DECIMAL 字段升级到5.0.6之后会发生崩溃

使用LVM快速建立数据库的快照

2007-04-20T11:50:00.000+08:00

LVM（逻辑卷管理器）是一种把硬盘驱动器空间分配成逻辑卷的方法，这样硬盘就不必使用分区而被简易地重划大小。下图是LVM的主要结构。

使用LVM可以快速的对一个逻辑卷做快照，所以可以为不能停机的数据库做快照。如果我们要对一个数据库系统做快照，数据库的数据文件必须在一个逻辑卷上，而不能只使用传统的分区。虽然可以把一个物理分区转成LVM的卷，但这个操作需要先卸载分区，所以如果希望不关闭数据库，在安装数据库时就需要使用LVM。

建立逻辑卷的步骤：
1. 首先使用fdisk建立新的分区（假设为/dev/sda3），并使用t指令把分区类型改成8e。使用p指令可以看到system为Linux LVM


Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1          13      104391   83  Linux
/dev/sda2              14         650     5116702+  83  Linux
/dev/sda3             651        1287     5116702+  8e  Linux LVM
/dev/sda4            1288        9726    67786267+   5  Extended
/dev/sda5            1670        1924     2048256   82  Linux swap

2. 使用 pvcreate /dev/sda3 建立物理卷

3. 然后使用 vgcreate db /dev/sda3 建立卷组。这里卷组中只用了一个物理卷，也可以有多个，如：vgcreate db /dev/sda1 /dev/sda3

4. 激活卷组（可能需要）vgchange -a y db

5. 可以使用 vgdisplay -v db 查看卷组的状态

6. 在卷组上建立逻辑卷。lvcreate -L 50G -n main db

7. 建立文件系统，mke2fs /dev/db/main

8. 挂载卷。mount /dev/db/main /var/db

假设逻辑卷/dev/db/main已经挂载为数据库的数据目录/var/db，/dev/db是逻辑卷组。如果/dev/db中还有空余的空间，那么可以直接建立快照，否则需要为卷组增加空间。使用 vgextend db /dev/sdb1 增加一个新的物理卷。

下面来建立快照：
1. 使用 flush tables with read lock 给表加锁。操作结束了不要推出mysql client，否则就会解锁了。
注意：如果你当前正在执行一个较长时间的查询，那么这个命令可能需要较长时间才能完成。

2. 开一个新的shell，使用 lvcreate -L10G -s -n backup /dev/db/main 建立main卷的快照backup。备份过程中务必指定足够大的撤销空间用于保存发生变化的东西。这里指定了10GB。如果撤销空间不够大，快照就会无效。这个命令应该是只需要几秒的时间。
如果遇到这样的错误，“snapshot: Required device-mapper target(s) not detected in your kernel”，需要执行 modprobe dm-snapshot。
当快照存在时重启服务器可以会出现卷无法挂载的错误，错误信息为：mount: special device /dev/db/main does not exist。这里也需要执行 modprobe dm-snapshot 并激活卷组 vgchange -a y db

3. 在1中的mysql client里解锁，unlock tables

4. 挂载backup，然后将快照拷贝出来

5. 卸载backup

6. 删除快照 lvremove /dev/db/backup

mysql如何区分大小写

2007-04-15T20:27:00.000+08:00

是否区分大小写和校对规则有关，默认设的规则是大小写不敏感的。
show create table如果看到collate是ci结尾，那么就是不区别的，如果cs或bin结尾，就是区别的。
如果建表的时候选择的是区别大小写的规则而查询的时候又暂时不想区别，
可以用类似
WHERE column_name COLLATE latin1_general_ci = 'xxx'
的写法改变查询使用的校对规则

使用延迟的join来优化count(*)和limit语句（翻译）

2007-04-11T10:23:00.000+08:00

在很多运用中，常有这样的结构，一个主表和一个附加表，附加表用来存一些附加信息，取数据的时候需要和主表连接。

如果你在这样的结构上执行count(*)，那么即使使用了left join，MySQL仍然会做连接。同样的如果使用了limit，MySQL也会连接一些最终会扔掉的行。当limit的偏移量很大的时候，这样的连接是很浪费时间的。

对于这样的情况，你可以帮助MySQL不要对count(*)做连接或者做了limit之后再连接。

请看下面的例子：


   1      CREATE TABLE `fact` (
   2        `i` int(10) UNSIGNED NOT NULL,
   3        `val` int(10) UNSIGNED NOT NULL,
   4        KEY `i` (`i`,`val`)
   5      )
   6       
   7      CREATE TABLE `dim` (
   8        `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
   9        `pad` varchar(100) NOT NULL,
  10        PRIMARY KEY  (`id`)
  11      )
  12       
  13      mysql> SELECT count(*) FROM dim;
  14      +----------+
  15      | count(*) |
  16      +----------+
  17      |    30720 |
  18      +----------+
  19      1 row IN SET (0.00 sec)
  20       
  21      mysql> SELECT count(*) FROM fact;
  22      +----------+
  23      | count(*) |
  24      +----------+
  25      |  7340032 |
  26      +----------+
  27      1 row IN SET (0.00 sec)
  28       
  29      mysql> SELECT count(*) FROM fact WHERE i<10000;
  30      +----------+
  31      | count(*) |
  32      +----------+
  33      |   733444 |
  34      +----------+
  35      1 row IN SET (0.44 sec)
  36       
  37       
  38      mysql> SELECT count(*) FROM fact LEFT JOIN dim ON val=id WHERE i<10000;
  39      +----------+
  40      | count(*) |
  41      +----------+
  42      |   733444 |
  43      +----------+
  44      1 row IN SET (2.15 sec)
  45       
  46       
  47      mysql> SELECT i,pad FROM fact LEFT JOIN dim ON val=id WHERE i<10000 LIMIT 500000,10;
  48      +------+------------------------------------------+
  49      | i    | pad                                      |
  50      +------+------------------------------------------+
  51      | 6811 | 06bfea523be29a6070488ee66e874dffa170de76 |
  52      | 6811 | 3baf40c2d76998270f8954bedda386b5021e0624 |
  53      | 6811 | 35ad5c3a9d0763acc305992327864bed1af34167 |
  54      | 6811 | 81de98a3ef74ddc0fa4f7c95a27e3dbebca8df0d |
  55      | 6811 | 11cde5d0bd8ffe1eda86b39d05a58c525e8fac8f |
  56      | 6811 | 25c474b380388c23b1de730c4255612e1233e14e |
  57      | 6811 | 1d32b5ba28a513097fc88f3efd91155b2697aeec |
  58      | 6811 | bdc9a39cdfafda26fc2f48a48abd3bc5f051a4ea |
  59      | 6811 | d2e6cb9ca5aa9dd2bc3d033de45579a76ccdafdf |
  60      | 6811 | 0130c708083d77377255bd8f5e0daa15fbb24212 |
  61      +------+------------------------------------------+
  62      10 rows IN SET (3.88 sec)
  63       
  64      mysql> SELECT i,pad FROM (SELECT i,val FROM fact WHERE i<10000 LIMIT 500000,10) res LEFT JOIN dim ON val=id;
  65      +------+------------------------------------------+
  66      | i    | pad                                      |
  67      +------+------------------------------------------+
  68      | 6811 | 06bfea523be29a6070488ee66e874dffa170de76 |
  69      | 6811 | 3baf40c2d76998270f8954bedda386b5021e0624 |
  70      | 6811 | 35ad5c3a9d0763acc305992327864bed1af34167 |
  71      | 6811 | 81de98a3ef74ddc0fa4f7c95a27e3dbebca8df0d |
  72      | 6811 | 11cde5d0bd8ffe1eda86b39d05a58c525e8fac8f |
  73      | 6811 | 25c474b380388c23b1de730c4255612e1233e14e |
  74      | 6811 | 1d32b5ba28a513097fc88f3efd91155b2697aeec |
  75      | 6811 | bdc9a39cdfafda26fc2f48a48abd3bc5f051a4ea |
  76      | 6811 | d2e6cb9ca5aa9dd2bc3d033de45579a76ccdafdf |
  77      | 6811 | 0130c708083d77377255bd8f5e0daa15fbb24212 |
  78      +------+------------------------------------------+
  79      10 rows IN SET (0.30 sec)

可以看到使用的小技巧改善了速度。

mysql监视分析工具

2007-03-27T11:14:00.000+08:00

mysqlbinlog 这个大家都应该知道的，用来看mysql的binlog的。mysql自带。

mysqldumpslow 用于分析mysql的slow log。自带的。结果如下。


Count: 1  Time=4.00s (4s)  Lock=0.00s (0s)  Rows=0.0 (0), root[root]@[127.0.0.1]
  select * from user ignore key (PRIMARY)  where address = 'S' order by id asc limit N

Count: 3  Time=4.00s (12s)  Lock=0.00s (0s)  Rows=0.0 (0), root[root]@[127.0.0.1]
  select * from user  where address = 'S' order by id asc limit N

Count: 2  Time=4.00s (8s)  Lock=0.00s (0s)  Rows=32.0 (64), root[root]@[127.0.0.1]
  select count(*), age from user group by age with rollup

mysql_explain_log 分析mysql的通用查询日志（用log选项打开的），自带的。需要注意的是用客户端连接mysql的时候需要指定数据库，使用use XXX选择数据库的时候此工具无法分辨出sql使用的是什么数据库。


explain_log     provided by http://www.mobile.de
===========     ================================

Index usage ------------------------------------

Table   test.user: ---
 count  key:
  1     PRIMARY
 count  possible_keys:
  1     PRIMARY
 count  type:
  1     ALL
  1     range

Queries causing table scans -------------------

EXPLAIN select * from test.user
Sum: 1 table scans

Summary ---------------------------------------

Select:         4 queries
Update:         0 queries

Init:           0 times
Field:          6 times
Refresh:        0 times
Query:          35 times
Statistics:     0 times

Logfile:        59 lines
Started:        Tue Mar 27 10:45:12 2007
Finished:       Tue Mar 27 10:45:12 2007

perror 显示错误码对应的错误信息。mysql自带。


shell>perror 13
OS error code  13:  Permission denied

mysqlslap 一个性能测试的工具。mysql的test suite中带的。

mtop 一个进程监视的工具，可以直接在里面显示出explain的结果。也可以使用watch -n 1 mysqladmin status processlist来监视。


127.0.0.1  mysqld 5.0.27-standard-log up 0 day(s),  0:10 hrs
1 threads: 1 running, 1 cached. Queries/slow: 26/0 Cache Hit: 100.00%
Opened tables: 0  RRN: 467  TLW: 0  SFJ: 0  SMP: 0  QPS: 0

ID       USER     HOST             DB           TIME   COMMAND STATE        INFO
26       root     1270.0.1:52841                       Query                show full processlist

mysql_explain_slow_log 和mysql_explain_log差不多，不过这个是分析slow log的。


mysql_explain_slow_log
======================

Index usage ------------------------------------

Table   test: ---
 count  type:
  10    ALL

Table   test.click: ---
 count  type:
  1     ALL

Table   test.user: ---
 count  key:
  1     username,useraa
  9     usertime
  16    PRIMARY
  29    useraa
 count  possible_keys:
  1     PRIMARY
  7     useraa,username
  9     usertime
  23    useraa
 count  type:
  1     index_merge
  2     range
  23    ref
  29    index
  31    ALL

Queries causing table scans -------------------
EXPLAIN select * from test.user
EXPLAIN select * from test.user order by rand() limit 5
省略若干行...

Sum: 56 table scans

Summary ---------------------------------------

Select:         97 queries
Update:         0 queries
Load:   33 queries

Logfile:        1657 lines
Started:        Tue Mar 27 11:01:14 2007
Finished:       Tue Mar 27 11:01:14 2007

mysqlreport 监视分析mysql状态的工具。


MySQL 5.0.27-standard-l  uptime 0 0:17:57       Tue Mar 27 11:04:15 2007

__ Key _________________________________________________________________
Buffer used         0 of  32.00M  %Used:   0.00
  Current       3.68M            %Usage:  11.51
Write ratio     0.000
Read ratio      0.000

__ Questions ___________________________________________________________
Total             170     0.2/s
Slow                0       0/s  %Total:   0.00  %DMS:   0.00
DMS               105     0.1/s           61.76

__ Table Locks _________________________________________________________
Waited              0       0/s  %Total:   0.00
Immediate         109     0.1/s

__ Tables ______________________________________________________________
Open                8 of 2048    %Cache:   0.39
Opened             14     0.0/s

__ Connections _________________________________________________________
Max used            2 of  500      %Max:   0.40
Total              38     0.0/s

__ Created Temp ________________________________________________________
Disk table          0       0/s
Table              16     0.0/s
File                5     0.0/s

mysqlsla 分析mysql的各种日志。分析slow log的结果如下。


Reading slow log 'db-slow.log'
170 total queries, 72 unique
Sorting by 't'

__ 001 _______________________________________________________________________

Count         : 15 (8%)
Time          : 1297.000 total, 86.467 avg, 3.000 min to 833.000 max
                9:20% 10:13% 833:6% 67:6% 57:6% 3:6% 61:6% 58:6% 20:6% 103:6% (87%)
Lock          : 0.000 total, 0.000 avg, 0.000 min to 0.000 max
Rows sent     : 0 avg, 0 min to 0 max
Rows examined : 0 avg, 0 min to 0 max
User          : root[root]@/127.0.0.1 (100%)

SET insert_id=N;
LOAD data infile 'S' INTO table user;
省略若干行...

mysqlsniffer 监听mysql通讯的工具。


mysqlsniffer listening for MySQL on interface eth0 port 3306
server > 192.168.1.170.32958: ID 0 len 65 Handshake 
192.168.1.170.32958 > server: ID 1 len 38 Handshake (new auth) 
server > 192.168.1.170.32958: ID 2 len 7 OK 
192.168.1.170.32958 > server: ID 0 len 18 COM_QUERY: SELECT DATABASE()
server > 192.168.1.170.32958: ID 1 len 1 1 Fields
        ID 2 len 32 Field: ..DATABASE() 
        ID 3 len 5 End 
        ID 4 len 1 || NULL ||
        ID 5 len 5 End 
192.168.1.170.32958 > server: ID 0 len 5 COM_INIT_DB: test
server > 192.168.1.170.32958: ID 1 len 7 OK 
192.168.1.170.32958 > server: ID 0 len 15 COM_QUERY: show databases
server > 192.168.1.170.32958: ID 1 len 1 1 Fields
        ID 2 len 49 Field: .SCHEMATA.Database 
        ID 3 len 5 End 
        ID 4 len 19 || information_schema ||
        ID 5 len 3 || aa ||
        ID 6 len 6 || mysql ||
        ID 7 len 7 || sakila ||
        ID 8 len 5 || test ||
        ID 9 len 6 || world ||
        ID 10 len 5 End 
192.168.1.170.32958 > server: ID 0 len 12 COM_QUERY: show tables
server > 192.168.1.170.32958: ID 1 len 1 1 Fields
        ID 2 len 57 Field: .TABLE_NAMES.Tables_in_test 
        ID 3 len 5 End 
        ID 4 len 6 || click ||
        ID 5 len 8 || s_click ||
        ID 6 len 5 || user ||
        ID 7 len 5 End 
192.168.1.170.32958 > server: ID 0 len 7 COM_FIELD_LIST: click
server > 192.168.1.170.32958: ID 1 len 42 Field: test.click.id 
        ID 2 len 51 Field: test.click.user_id 
        ID 3 len 62 Field: test.click.promotion_id 
        ID 4 len 49 Field: test.click.status 
        ID 5 len 78 Field: test.click.record_time 
        ID 6 len 5 End 
192.168.1.170.32958 > server: ID 0 len 9 COM_FIELD_LIST: s_click
server > 192.168.1.170.32958: ID 1 len 46 Field: test.s_click.id 
        ID 2 len 66 Field: test.s_click.promotion_id 
        ID 3 len 53 Field: test.s_click.status 
        ID 4 len 59 Field: test.s_click.click_num 
        ID 5 len 73 Field: test.s_click.record_date 
        ID 6 len 5 End 
192.168.1.170.32958 > server: ID 0 len 6 COM_FIELD_LIST: user
server > 192.168.1.170.32958: ID 1 len 40 Field: test.user.id 
        ID 2 len 43 Field: test.user.name 
        ID 3 len 45 Field: test.user.email 
        ID 4 len 49 Field: test.user.address 
        ID 5 len 41 Field: test.user.age 
        ID 6 len 76 Field: test.user.regist_time 
        ID 7 len 5 End 
192.168.1.170.32958 > server: ID 0 len 27 COM_QUERY: select * from user limit 1
server > 192.168.1.170.32958: ID 1 len 1 6 Fields
        ID 2 len 38 Field: test.user.id 
        ID 3 len 42 Field: test.user.name 
        ID 4 len 44 Field: test.user.email 
        ID 5 len 48 Field: test.user.address 
        ID 6 len 40 Field: test.user.age 
        ID 7 len 56 Field: test.user.regist_time 
        ID 8 len 5 End 
        ID 9 len 34 || 1 | ll | ff | ll | 10 | 2007-03-21 09:58:07 ||
        ID 10 len 5 End 
192.168.1.170.32958 > server: ID 0 len 1 COM_QUIT
192.168.1.57.60248 > server: ID 0 len 48 COM_QUERY: SELECT COUNT(*) FROM product WHERE index_flag=0
server > 192.168.1.57.60248: ID 1 len 1 1 Fields
        ID 2 len 30 Field: ..COUNT(*) 
        ID 3 len 1 End
        ID 4 len 2 || 0 ||
        ID 5 len 5 End 
70 MySQL packets captured (2022 bytes)

下载

小心太大的query_cache

2007-03-26T11:28:00.000+08:00

当query_size过大，比如说有256M或者更多，而又缓存了很多query（Qcache_queries_in_cache），在加上一条插入语句可能使很多的缓存无效，那么插入就会变得很慢，因为有一个使大量缓存无效的过程。可以使用flush query cache清除缓存看一下需要多长时间。解决方法可以减小缓存，或者使用外部的缓存如memcached。

性能测试

2007-03-20T16:11:00.000+08:00

做了一个insert into on duplicate key update的性能测试。
原始表有200万数据，有4个字段（不包括主键），unique key为其中一个字段。
直接插入2万条无重复的数据使用了1.74秒。
使用on duplicate key update插入1万条数据，更新1万条唯一键重复的数据使用了2.96秒。
使用replace则是使用了3.32秒，大概是因为replace是先删除再插入，速度慢一点。
如果自己select之后判断则更慢了，需要4.32秒。
另外on duplicate key update和replace如果都是插入无重复的数据则速度和直接插入差不多。

在MySQL中如何为连接添加索引

2007-03-14T12:01:00.000+08:00

译文：

我先通过一个简单的例子说明在MySQL中如何为连接添加索引，然后再看一个有挑战性的例子。

简单的3个表的连接

表结构很简单，3个表tblA, tblB, tblC，每个表有3个字段：col1, col2, col3。
在没有索引的情况下连接3个表


   SELECT
      *
   FROM
      tblA,
      tblB,
      tblC
   WHERE
          tblA.col1 = tblB.col1
      AND tblA.col2 = tblC.col1;

explain的结果如下：


   +-------+------+---------------+------+---------+------+------+-------------+
   | table | type | possible_keys | key  | key_len | ref  | rows | Extra       |
   +-------+------+---------------+------+---------+------+------+-------------+
   | tblA  | ALL  | NULL          | NULL |    NULL | NULL | 1000 |             |
   | tblB  | ALL  | NULL          | NULL |    NULL | NULL | 1000 | Using where |
   | tblC  | ALL  | NULL          | NULL |    NULL | NULL | 1000 | Using where |
   +-------+------+---------------+------+---------+------+------+-------------+

最后，在MySQL的手册中(7.2.1)：
表以它们在处理查询过程中将被MySQL读入的顺序被列出。MySQL用一遍扫描多次联接（single-sweep multi-join）的方式解决所有联接。这意味着MySQL从第一个表中读一行，然后找到在第二个表中的一个匹配行，然后在第3个表中等等。当所有的表处理完后，它输出选中的列并且返回表清单直到找到一个有更多的匹配行的表。从该表读入下一行并继续处理下一个表。
如手册所说的，MySQL读第一个表(tnlA)，然后第二个(tblB)，然后第三个(tblC)，像explain中输出的一样。先前的表中的值用来查找当前表中的行。在我们的例子中，tblA中的值用来找tblB中的匹配行，然后tblB的值来找tblC的行。当一个完整的扫描结束(在表tblA,tblB,tblC中找到了结果)，MySQL不会返回tblA,它到tblB中查看是否有更多的行匹配当前tblA的值。如果有，它拿出这一行，然后再在tblC中找匹配的。记住MySQL连接的基本原则是很重要的：先前的表中的值用来查找当前表中的行。

按原理建索引

知道了MySQL使用从tblA中得到的值查找tblB中的行，我们需要怎么建索引来帮助MySQL？为此我们要知道它需要什么。考虑连接tblA和tblB：它们通过“tblA.col1 = tblB.col1”来连接。我们已经有了tblA.col1的值，所以MySQL需要一个tblB.col1的值来完成等值操作。因此如果MySQL需要tblB.col1，我们就在tblB.col1上加索引。加了之后，这是新的explain结果：


   +-------+------+---------------+----------+---------+-----------+------+-------------+
   | table | type | possible_keys | key      | key_len | ref       | rows | Extra       |
   +-------+------+---------------+----------+---------+-----------+------+-------------+
   | tblA  | ALL  | NULL          | NULL     |    NULL | NULL      | 1000 |             |
   | tblB  | ref  | ndx_col1      | ndx_col1 |       5 | tblA.col1 |    1 | Using where |
   | tblC  | ALL  | NULL          | NULL     |    NULL | NULL      | 1000 | Using where |
   +-------+------+---------------+----------+---------+-----------+------+-------------+

如上，MySQL现在使用ndx_col1索引来连接tblB到tblA。就是说，当MySQL要找tblB中的行时，使用了ndx_col1索引通过tblA.col1的值直接得到匹配的行，而不是像以前需要做表扫描。这就是为什么tblB的ref列说“tablA.col1”。tblC现在还是用表扫描，这可以通过同样的方法解决。查看MySQL的需求：从sql中连接两表的语句“tblA.col2 = tblC.col1”可以看出它需要tblC.col1因为我们已经有了tblA.col2。给这一列加上索引之后explain：


   +-------+------+---------------+----------+---------+-----------+------+-------------+
   | table | type | possible_keys | key      | key_len | ref       | rows | Extra       |
   +-------+------+---------------+----------+---------+-----------+------+-------------+
   | tblA  | ALL  | NULL          | NULL     |    NULL | NULL      | 1000 |             |
   | tblB  | ref  | ndx_col1      | ndx_col1 |       5 | tblA.col1 |    1 | Using where |
   | tblC  | ref  | ndx_col1      | ndx_col1 |       5 | tblA.col2 |    1 | Using where |
   +-------+------+---------------+----------+---------+-----------+------+-------------+

更复杂的查询

在实际中不会遇到刚才那种sql。所以你可能更想看看这样的：


   SELECT
      COUNT(tblB.a_id) as correct,
      tblA.type,
      tblA.se_type
   FROM
      tblA,
      tblB,
      tblC,
      tblD
   WHERE
          tblA.ex_id = tblC.ex_id
      AND tblC.st_ex_id = tblB.st_ex_id
      AND tblB.q_num = tblA.q_num
      AND tblB.se_num = tblA.se_num
      AND tblD.ex_id = tblA.ex_id
      AND tblD.exp <> tblB.se_num
      AND tblB.ans = tblA.ans
      AND tblA.ex_id = 1001
      AND tblC.r_id = 542
   GROUP BY
      tblA.type,
      tblA.se_type;

乍一看是很复杂的：有4个表，有聚合函数，有9个where条件，还有一个group by。explain的伟大之处在于我们现在可以忽略这些，每次只看两个表，判断每一步MySQL需要什么。这是一个实际的查询，只是字段名有一些改动。explain的结果：


   +-------+--------+---------------+---------+---------+---------------+-------+----------------------------------------------+
   | table | type   | possible_keys | key     | key_len | ref           | rows  | Extra                                        |
   +-------+--------+---------------+---------+---------+---------------+-------+----------------------------------------------+
   | tblA  | ALL    | NULL          | NULL    |    NULL | NULL          |  1080 | Using where; Using temporary; Using filesort |
   | tblB  | ALL    | NULL          | NULL    |    NULL | NULL          | 87189 | Using where                                  |
   | tblC  | eq_ref | PRIMARY       | PRIMARY |       4 | tblB.st_ex_id |     1 | Using where                                  |
   | tblD  | eq_ref | PRIMARY       | PRIMARY |       4 | tblA.ex_id    |     1 | Using where                                  |
   +-------+--------+---------------+---------+---------+---------------+-------+----------------------------------------------+

判断连接影响的主要看结果集。结果集就是查询的结果。对于连接，一个估计结果集大小的方法是把MySQL预测的读取每个表的行数相乘。作为估计，这样做比较偏向于坏的情况，因为where条件通常会减少很多的行数。但这个查询的结果集有9400万行。这就是没有索引连接很危险的原因；几千行乘几千行你就会有一个上百万的结果集了。
那么现在这个查询需要什么？从tblA和tblB开始。在sql中：


AND tblB.q_num = tblA.q_num
AND tblB.se_num = tblA.se_num
AND tblB.ans = tblA.ans

MySQL至少需要q_num, se_num, ans中的一个。我选择在se_num和q_num上加索引因为在几乎所有其他的查询中我都会需要它们。折中是优化的一部分，多数人没有时间去为每一个查询找最优的索引方案，只能是找到一个对于大多数情况而言最优的方案。在tblB上加索引(se_num, q_num)，explain的结果：


   +-------+--------+---------------+-------------+---------+------------------------+------+----------------------------------------------+
   | table | type   | possible_keys | key         | key_len | ref                    | rows | Extra                                        |
   +-------+--------+---------------+-------------+---------+------------------------+------+----------------------------------------------+
   | tblA  | ALL    | NULL          | NULL        |    NULL | NULL                   | 1080 | Using where; Using temporary; Using filesort |
   | tblB  | ref    | ndx_secn_qn   | ndx_secn_qn |       2 | tblA.se_num,tblA.q_num |  641 | Using where                                  |
   | tblC  | eq_ref | PRIMARY       | PRIMARY     |       4 | tblB.st_ex_id          |    1 | Using where                                  |
   | tblD  | eq_ref | PRIMARY       | PRIMARY     |       4 | tblA.ex_id             |    1 | Using where                                  |
   +-------+--------+---------------+-------------+---------+------------------------+------+----------------------------------------------+

现在结果集下降了99.3%变为692280行。但为什么要停在这里？我们可以很容易的解决tblA的表扫描。因为它是第一个表，我们并不需要为连接加索引，这在tblB上已经做过了。一般来说，给第一个表加索引可以把它当成只在这一个表上查询的情况。在这个例子中很幸运，tblA是："AND tblA.ex_id = 1001"。我们只需要加ex_id索引：


   +-------+--------+---------------+-------------+---------+------------------------+------+----------------------------------------------+
   | table | type   | possible_keys | key         | key_len | ref                    | rows | Extra                                        |
   +-------+--------+---------------+-------------+---------+------------------------+------+----------------------------------------------+
   | tblA  | ref    | ndx_ex_id     | ndx_ex_id   |       4 | const                  |    1 | Using where; Using temporary; Using filesort |
   | tblB  | ref    | ndx_secn_qn   | ndx_secn_qn |       2 | tblA.se_num,tblA.q_num |  641 | Using where                                  |
   | tblC  | eq_ref | PRIMARY       | PRIMARY     |       4 | tblB.st_ex_id          |    1 | Using where                                  |
   | tblD  | eq_ref | PRIMARY       | PRIMARY     |       4 | tblA.ex_id             |    1 | Using where                                  |
   +-------+--------+---------------+-------------+---------+------------------------+------+----------------------------------------------+

现在结果集是641行。相比开始的9400万，可以说了下降了100%。如果继续研究这个查询我们还可以去掉temp table和filesort，但现在查询已经很快了，也已经说明了如何为连接加索引。尽管最初看这个查询很麻烦，但可以看到只要每次独立的看两张表，为MySQL的需求加索引，整个过程并不困难。

结论

为复杂的连接加索引要认识到两件事：

1. 不管sql多复杂，每次只看explain中的两个表

2. 先前表中的值已经有了，我们的工作就是通过索引帮助MySQL在当前表中使用这些值来找到匹配行

Incorrect information in file 错误

2007-03-09T13:41:00.000+08:00

更改了innodb的日志文件大小，即innodb_log_file_size的值，重启mysql之后对innodb的表都会报错：[ERROR] /usr/local/mysql/bin/mysqld: Incorrect information in file: './a/b.frm'。解决办法是修改其值后把日志文件ib_logfile删掉再启动mysql（请注意备份）。

注：删log之前确保innodb_fast_shutdown的值不是2，如果是2则需要先改为1，然后重启使之生效，再关闭mysql删log文件。其默认值是1。

参考：http://dev.mysql.com/doc/refman/5.0/en/adding-and-removing.html

hackmysql

2007-03-09T10:47:00.000+08:00

http://hackmysql.com/
mysql的一些工具，report, sniffer等
其中mysqlsniffer使用下面的命令编译

gcc -O2 -lpcap -o mysqlsniffer mysqlsniffer.c packet_handlers.c misc.c

union的性能

2007-03-07T15:07:00.000+08:00

mysql的union操作是先做查询然后把结果集求并。union的过程中会使用到临时表，所以当结果集比较小时，union的速度比较快，5万的结果集union all一次大约要1，2秒的时间，但如果是50万的结果集可能就要100秒了。因此如果结果集很大应该尽量避免使用union，尤其是union all，完全可以通过两次查询得到。

为MySQL添加帮助信息

2007-03-07T11:29:00.000+08:00

在MySQL的网站上下载它提供的帮助文件，http://dev.mysql.com/doc/，MySQL Help Tables。
然后直接导入到MySQL的系统数据库中
mysql mysql < file_name
之后用MySQL自带client（就是mysql命令）连接就可以使用帮助，比如

mysql> help create index
Name: 'CREATE INDEX'
Description:
Syntax:
CREATE [UNIQUE|FULLTEXT|SPATIAL] INDEX index_name
   [index_type]
   ON tbl_name (index_col_name,...)

index_col_name:
   col_name [(length)] [ASC | DESC]

index_type:
   USING {BTREE | HASH}

CREATE INDEX is mapped to an ALTER TABLE statement to create indexes.
See [HELP ALTER TABLE]. For more information about indexes, see
http://dev.mysql.com/doc/refman/5.0/en/mysql-indexes.html.

URL: http://dev.mysql.com/doc/refman/5.0/en/create-index.html

建表要使记录尽可能小

2007-03-06T16:32:00.001+08:00

建表的时候记录的长度越短越好，越短则IO操作越少，查询越快。
能用int就不要用bigint，而如果能用tinyint是最好的。
定义varchar时按照业务需要设置长度，不要一律varchar(255)，这样虽然并不会增加储存空间，但如以前提过的MySQL使用临时表是会把 varchar字段变成char，这样会增加临时表的大小，降低查询速度。同样的道理，对于不会使用utf8的字段（如：email, url），也不要用utf8的格式，因为MySQL必须为char(10)保留30个字节。
用指明not null的时候也最好指明，这样也可以减少记录的长度。

导入数据时是否需要禁用索引

2007-02-28T15:26:00.000+08:00

使用load data导入数据，如果导入的表是MyISAM的，对于空表，MySQL会把所有的非唯一索引进行一次独立的处理，而对于非空的表则会边插入边建索引。
所以对于非空的MyISAM表，需要用alter table xxx disable keys禁用索引，导入完成之后再用alter table xxx enable keys打开。
对于innodb，从测试的结果看无论表中是否已有记录，索引都是单独处理的，所以无需禁用索引。

临时表过大

2007-02-26T15:51:00.001+08:00

今天遇到一个这样的错误：


ERROR 126 (HY000): Incorrect key file for table '/tmp/#sql_dbd_0.MYI'; try to repair it

发现其原因是临时表太大了，而/tmp分区只有2G，放不下就报错了。
sql是这样的：


select promotion.promotion_id,
      client.* ,
      thanks.thanks_id,
      thanks.thanks_type,
      draft.draft_id,
      rand() as s
    from promotion, client, thanks, draft
    where promotion.client_id = client.client_id
      and promotion.promotion_id = thanks.promotion_id
      and promotion.promotion_id = draft.promotion_id
    order by s
    limit 10

如果把中间结果自己建一个临时表


create temporary table tmp select ...

建出的表文件只有100M左右，那么为什么/tmp中会放不下呢？
这是因为MySQL自己建的临时表都是静态行。如果使用下面的语句建表


create temporary table tmp row_format=fixed select ...

会出现同样的错误了。


ERROR 126 (HY000): Incorrect key file for table '/tmp/#sqldbd_6bd_0.MYI'; try to repair it

所以这个问题有两个解决方法：
1. 自己建临时表
2. 加大临时目录。可以加大/tmp分区，也可以在启动MySQL时设置TMPDIR环境变量指定另外的临时目录

MySQL测试一

2007-02-25T18:55:00.001+08:00

做了一些简单的测试，以熟悉一些平时不用的命令。
测试的环境：
CPU：Intel(R) Xeon(R) CPU 3040 @ 1.86GHz X 2
MEM: 1G
HD: SATA 7200/m

一张表，1130025数据，记录平均长61。


CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(40) default NULL,
  `email` varchar(255) default NULL,
  `address` varchar(255) default NULL,
  `age` int(11) default NULL,
  `regist_time` timestamp NOT NULL default CURRENT_TIMESTAMP on update CURRENT_T
  PRIMARY KEY  (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=1130026 DEFAULT CHARSET=utf8

无其他索引。
dump数据用mysqldump和select * into outfile用的时间都差不多，都是5秒。
使用innodb时，导入数据用load data infile需要18秒左右，mysql < user.sql需要30秒左右。
user.sql中insert是一次插入15522个记录，用mysqldump -e（-e似乎是自动的，没发现怎么一个insert一个记录）自动分的，不知道为什么是这个数字。
将innodb转成myisam用了8.35秒，转后使用的硬盘差不多，都是60M左右。
然后用load data只用了9秒就把数据导入了。用mysql < user.sql则是22秒。
再把myisam转成innodb用了10.92秒，看来先用myisam导入再转innodb和直接用innodb导入使用的时间差不多。
mysql的文档说导入myisam表时加大key_buffer_size可以提高导入的速度，我把该值从32M改成128M，速度没有变化。可能32M就已经足够了。

emacs的shell mode中使用 ansi color

2007-02-15T17:55:00.001+08:00

(autoload 'ansi-color-for-comint-mode-on "ansi-color" nil t)
(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)

有用的调试工具

2007-02-09T09:16:00.000+08:00

truss, strace, ltrace。这三个工具都可以显示出程序运行的信息，虽然不能准确找到出错的地方，但可以提供一些线索。像unix中经常出现的segment fault就可以用它们试试。其中strace和ltrace在centos上可以直接用yum安装。

MySQL的datetime设置当前时间为默认值

2007-02-08T14:47:00.000+08:00

由于MySQL目前字段的默认值不支持函数，所以以

create_time datetime default now()

的形式设置默认值是不可能的。

代替的方案是使用TIMESTAMP类型代替DATETIME类型。

TIMESTAMP列类型自动地用当前的日期和时间标记INSERT或UPDATE的操作。
如果有多个TIMESTAMP列，只有第一个自动更新。
自动更新第一个TIMESTAMP列在下列任何条件下发生：

列值没有明确地在一个INSERT或LOAD DATA INFILE语句中指定。

列值没有明确地在一个UPDATE语句中指定且另外一些的列改变值。（注意一个UPDATE设置一个列为它已经有的值，这将不引起TIMESTAMP列被更新，因为如果你设置一个列为它当前的值，MySQL为了效率而忽略更改。）

你明确地设定TIMESTAMP列为NULL.

除第一个以外的TIMESTAMP列也可以设置到当前的日期和时间，只要将列设为NULL，或NOW()。

另外在5.0以上版本中也可以使用trigger来实现此功能。


create table test_time (
 id int(11),
 create_time datetime
);

delimiter |

create trigger default_datetime before insert on test_time
  for each row
     if new.create_time is null then
       set new.create_time = now();
     end if;|

delimiter ;

小心使用MySQL中的in

2007-02-01T13:44:00.001+08:00

在MySQL中，where语句里使用

(A,B) in ((X1,Y1),(X2,Y2))

如果没有(A,B)的索引，而只有A或B上的索引，则此索引不会被使用。
所以类似

select * from t1, t2 where (t1.a, t2.b) in ((1,2),(2,3))

的语句是无法使用a,b上的索引的，应该改为

select * from t1, t2 where  (t1.a = 1 and t2.b = 2) or (t1.a = 2 and t2.b = 3)

ssh agent

2007-01-16T19:13:00.000+08:00

今天终于知道 putty 的 Pageant.exe 是干什么的了。
假设本机上有私钥可以登录A和B。而B只有内网 ip，不能直接连，以前的做法是把私钥放到A上或者用A做代理。而用了 pageant 之后就无需在A上放私钥也可以从A连接到B。
步骤如下：
1. 运行 pageant
2. 在 pageant 中加入使用的私钥
3. 在 putty 的A的连接设置 auth 中把“Allow agent forwarding”选中
4. 用 putty 连接A
5. 然后直接在A的 shell 中输入 ssh B 就可以连接到 B 了
这样当要连接的内网机器比较多的时候很方便，不需要把私钥到处放了

HTTP的状态码

2007-01-10T15:52:00.000+08:00

今天有一个比较特殊的需求。在mod_perl中根据情况返回不同的状态码200和203，但都需要返回一张图片作为内容。本来是需要返回200和204的，但发现返回204的时候浏览器根本就不会显示内容。所以考虑返回203，这时候是可以正常显示的。
但是在mod_perl中自定义状态码一般写成


sub handler {
my $r = shift;
$r->custom_response(Apache2::Const::HTTP_NON_AUTHORITATIVE, $gif);
return Apache2::Const::HTTP_NON_AUTHORITATIVE;
}

$gif中是图片的内容，现在的问题是这样写头部中的content type不能自己设置，始终是text/html，导致不能正常显示。即使加上


$r->content_type("image/gif");

也没有效果，似乎返回不是Apache2::Const::OK时，这些设置都被忽略了。如果不用custom_response，直接print图片的内容，返回的状态码又会自动变成200，好像只要有输出就自动设成200了。
弄了半天，也没有发现有什么API能够直接更改返回的状态码。无奈，后来发现custom_response的第二个参数还可以用文件名，想着用文件名apache应该可以根据扩展名判断文件类型，可以一试。结果果然如此。
函数调用改成


$r->custom_response(Apache2::Const::HTTP_NON_AUTHORITATIVE, '/images/t.gif');

然后配置文件设置好扩展名的对应


AddType image/gif .gif

就可以了。

附HTTP的状态码，从Apache2::Const中抓出来的。


HTTP_CONTINUE:                       100
HTTP_SWITCHING_PROTOCOLS:            101
HTTP_PROCESSING:                     102
HTTP_OK:                             200
HTTP_CREATED:                        201
HTTP_ACCEPTED:                       202
HTTP_NON_AUTHORITATIVE:              203
HTTP_NO_CONTENT:                     204
HTTP_RESET_CONTENT:                  205
HTTP_PARTIAL_CONTENT:                206
HTTP_MULTI_STATUS:                   207
HTTP_MULTIPLE_CHOICES:               300
HTTP_MOVED_PERMANENTLY:              301
HTTP_MOVED_TEMPORARILY:              302
HTTP_SEE_OTHER:                      303
HTTP_NOT_MODIFIED:                   304
HTTP_USE_PROXY:                      305
HTTP_TEMPORARY_REDIRECT:             307
HTTP_BAD_REQUEST:                    400
HTTP_UNAUTHORIZED:                   401
HTTP_PAYMENT_REQUIRED:               402
HTTP_FORBIDDEN:                      403
HTTP_NOT_FOUND:                      404
HTTP_METHOD_NOT_ALLOWED:             405
HTTP_NOT_ACCEPTABLE:                 406
HTTP_PROXY_AUTHENTICATION_REQUIRED:  407
HTTP_REQUEST_TIME_OUT:               408
HTTP_CONFLICT:                       409
HTTP_GONE:                           410
HTTP_LENGTH_REQUIRED:                411
HTTP_PRECONDITION_FAILED:            412
HTTP_REQUEST_ENTITY_TOO_LARGE:       413
HTTP_REQUEST_URI_TOO_LARGE:          414
HTTP_UNSUPPORTED_MEDIA_TYPE:         415
HTTP_RANGE_NOT_SATISFIABLE:          416
HTTP_EXPECTATION_FAILED:             417
HTTP_UNPROCESSABLE_ENTITY:           422
HTTP_LOCKED:                         423
HTTP_FAILED_DEPENDENCY:              424
HTTP_UPGRADE_REQUIRED:               426
HTTP_INTERNAL_SERVER_ERROR:          500
HTTP_NOT_IMPLEMENTED:                501
HTTP_BAD_GATEWAY:                    502
HTTP_SERVICE_UNAVAILABLE:            503
HTTP_GATEWAY_TIME_OUT:               504
HTTP_VARIANT_ALSO_VARIES:            506
HTTP_INSUFFICIENT_STORAGE:           507
HTTP_NOT_EXTENDED:                   510

地震的后果

2006-12-28T00:34:00.000+08:00

一场地震断了光纤无数，今天MSN和SKYPE都连不上了。据“专家”说修复要一个月的时间，要换用QQ了。估计类似情况的人不少，马化腾爽啊。一年没用密码都忘记了，折腾了半天才能登录。唉，微软也真是，中国那么多人居然连一台服务器都不搬过来。

日文字符匹配

2006-12-27T11:32:00.000+08:00

以前程序用的EUC编码，在页面输入做检查时，使用的都是EUC的字符编码范围。主要是匹配全角カタカナ (?:\xA5[\xA1-\xF6]|\xA1[\xA6\xBC\xB3\xB4]) 和全角空格 (?:\xA1\xA1)。

现在程序改为UTF-8的了，再用上面的方式会很麻烦，需要把输入转成EUC再做。perl的正则表达式支持Unicode的属性，看上去用起来比直接写编码范围要清楚多了。全角カタカナ可以用 \p{Katakana}。而空格可以用 \p{IsSpace}，它包括\n,\t等，如果只是匹配空白可以用 \p{IsZs}。

暂时换个地方

2006-12-26T20:54:00.000+08:00

最近更新的时候总是失败，sitesled不能访问了。难以忍受了，正好现在blogspot解封了，再转回来。用了那么长时间sitesled，blogspot上的域名也没有了，想到的几个一看都是些没有什么东西又不更新的，唉。试了半天终于有个能用了。
http://qroom.blogspot.com

perl 代码优化 - 查找需要优化的部分

2006-12-22T11:47:00.000+08:00

做代码优化首先要知道程序各部分的速度，什么地方最慢，最需要优化。
下面有几种方法可以用于调查程序各部分的速度。

1. time

shell>time perl script.pl

这样可以得到程序的运行时间。

2. Time::HiRes
使用模块Time::HiRes中的函数gettimeofday，gettimeofday
例：

for (xxx) {
# code 1
$t0 = [gettimeofday];
# code 2
$elapsed = tv_interval ( $t0 );
$t += $slapsed;
# code 3
}

这样$t中就是代码段code 2在程序中执行总共需要的时间。这个结果是精确到微秒的。

3. Devel::DProf

# test.pl
sub d {
print 1;
}

sub g{
print 1 for 1..10;
}

sub f {
print 2;
}

for (1..10000){
d();
g();
f();
g();
}

# script end

shell>perl -d:DProf test.pl
shell>dprofpp
Total Elapsed Time = 0.289990 Seconds
User+System Time = 0.269990 Seconds
Exclusive Times
%Time ExclSec CumulS #Calls sec/call Csec/c Name
85.1 0.230 0.230 20000 0.0000 0.0000 main::g
14.8 0.040 0.040 10000 0.0000 0.0000 main::f
11.1 0.030 0.030 10000 0.0000 0.0000 main::d

4. Devel::SmallProf
shell>perl -d:SmallProf test.pl

shell>cat smallprof.out
================ SmallProf version 1.15 ================
Profile of a.pl Page 1
=================================================================
count wall tm cpu time line
10000 0.000000 0.000000 1:sub d {
10000 0.062426 0.090000 2:print 1;
0 0.000000 0.000000 3:}
0 0.000000 0.000000 4:
20000 0.000000 0.000000 5:sub g{
40000 0.390327 0.550000 6:print 1 for 1..10;
0 0.000000 0.000000 7:}
0 0.000000 0.000000 8:
10000 0.000000 0.000000 9:sub f {
10000 0.061660 0.100000 10:print 2;
0 0.000000 0.000000 11:}
0 0.000000 0.000000 12:
1 0.000006 0.000000 13:for (1..10000){
10000 0.036328 0.090000 14:d();
10000 0.037353 0.160000 15:g();
10000 0.038129 0.220000 16:f();
10000 0.038368 0.150000 17:g();
0 0.000000 0.000000 18:}
0 0.000000 0.000000 19:

shell>sort -k 2nr,2 smallprof.out
40000 0.390327 0.550000 6:print 1 for 1..10;
10000 0.062426 0.090000 2:print 1;
10000 0.061660 0.100000 10:print 2;
10000 0.038368 0.150000 17:g();
10000 0.038129 0.220000 16:f();
10000 0.037353 0.160000 15:g();
10000 0.036328 0.090000 14:d();
1 0.000006 0.000000 13:for (1..10000){
=================================================================
0 0.000000 0.000000 11:}
0 0.000000 0.000000 12:
0 0.000000 0.000000 18:}
0 0.000000 0.000000 19:
0 0.000000 0.000000 3:}
0 0.000000 0.000000 4:
0 0.000000 0.000000 7:}
0 0.000000 0.000000 8:
10000 0.000000 0.000000 1:sub d {
10000 0.000000 0.000000 9:sub f {
20000 0.000000 0.000000 5:sub g{
count wall tm cpu time line
Profile of a.pl Page 1
================ SmallProf version 1.15 ================

程序改进之后如果想知道效果如何，可以使用模块Benchmark。
例:

use Benchmark qw/timethse/;
timethese($count, {
'before' => sub { ...code1... },
'after' => sub { ...code2... },
});

上面这些模块的详细说明见各自的文档。

MySQL性能优化 - 参数调整

2006-12-16T01:13:00.000+08:00

无聊中，看到一片MySQL的文件，觉得不错，就翻译了一下，没想到用了1个多小时，好长啊。

原文：http://www.mysqlperformanceblog.com/2006/09/29/what-to-tune-in-mysql-server-after-installation/

我喜欢问别人在安装了MySQL之后，其默认的配置应该怎么改。但令人惊讶的是很多人都无法给出一个合理的理由。虽然MySQL有许多可以调整的变量，但对于大多数的情况它们中只有少数有用。只要把这几个设好了，其他的对于多数情况只能起到锦上添花的作用。

key_buffer_size
如果用MyISAM则非常重要。如果只用MyISAM表，那么设成可用内存的30%到40%。主要决定于索引的数量，数据的多少和读写量。要知道MyISAM是用系统的缓存来缓存数据的，而数据通常比索引大很多，所以你需要留一部分内存给系统。记得检查是否所有的key_buffer都被用到，经常看到有人把它设成4G，而所有的MYI文件加起来才1G（4G呀，看到的次数还不少，真是羡慕。内存不是这么浪费的）。如果用的MySIAM表很少，那么可以把它设得比较少，但至少要有16-32M，提供给创建的临时表的索引用。

innodb_buffer_pool_size
如果用Innodb，那么这是一个重要变量。相对于MyISAM来说，Innodb对于buffer size更敏感。MySIAM可能对于大数据量使用默认的key_buffer_size也还好，但Innodb在大数据量时用默认值就感觉在爬了。Innodb的缓冲池会缓存数据和索引，所以不需要给系统的缓存留空间，如果只用Innodb，可以把这个值设为内存的70%-80%。和key_buffer相同，如果数据量比较小也不怎么增加，那么不要把这个值设太高也可以提高内存的使用率。

innodb_additional_pool_size
这个的效果不是很明显，至少是当操作系统能合理分配内存时。但你可能仍需要设成20M或更多一点以看Innodb会分配多少内存做其他用途。

innodb_log_file_size
对于写很多尤其是大数据量时非常重要。要注意，大的文件提供更高的性能，但数据库恢复时会用更多的时间。我一般用64M-512M，具体取决于服务器的空间。

innodb_log_buffer_size
默认值对于多数中等写操作和事务短的运用都是可以的。如果经常做更新或者使用了很多blob数据，应该增大这个值。但太大了也是浪费内存，因为1秒钟总会flush（这个词的中文怎么说呢？）一次，所以不需要设到超过1秒的需求。8M-16M一般应该够了。小的运用可以设更小一点。

innodb_flush_log_at_trx_commit
抱怨Innodb比MyISAM慢100倍？那么你大概是忘了调整这个值。默认值1的意思是每一次事务提交或事务外的指令都需要把日志写入（flush）硬盘，这是很费时的。特别是使用电池供电缓存（Battery backed up cache）时。设成2对于很多运用，特别是从MyISAM表转过来的是可以的，它的意思是不写入硬盘而是写入系统缓存。日志仍然会每秒flush到硬盘，所以你一般不会丢失超过1-2秒的更新。设成0会更快一点，但安全方面比较差，即使MySQL挂了也可能会丢失事务的数据。而值2只会在整个操作系统挂了时才可能丢数据。

table_cache
打开表的操作代价很高。比如MyISAM表标记MYI头部来标记表在使用中。你不会希望频繁进行此操作，所以最好设置缓存使得能够保存大部分打开的表。它会用到一些系统资源和内存，但对于现在的硬件来说不是问题。对于200个表的运用1024比较好。如果你的连接数多，或者表多则再大一些。我见过超过100000的。

thread_cache
建立连接和断开时的线程的创建和死亡开销很大。我一般把它设为至少16。如果程序中有大量并发连接，而变量Threads_Created（status中可以看到）长得很快，那么会设大一些。主要是让正常操作中不要去创建线程。

query_cache
如果你的程序有大量的读操作而又没有程序级的缓存，那么把它设大一点应该有很大的帮助。但设得太大会减慢速度因为维护的开销很大。32M-512M就可以了。设过之后检查一下是否运行良好。For certain workloads cache hit ratio is lower than would justify having it enabled.（这句看不懂，我怀疑他写错了。一般来说，如果hit ratio比较低说明cache还不够大，可以适当的增加）

注意：这些都是一些全局变量。它们依赖于硬件和存储引擎，而session的变量更偏重于负荷。如果你只做简单的查询，那么即使你有64G的内存可以浪费也没理由要增加sort_buffer_size。而且这样还可能会降低性能。我一般会把session变量的调整放到第二步，在弄清了负荷以后。

另外MySQL提供的my.cnf的样例不错，可以拿来改改了用。

〜 and ～

2006-12-13T15:18:00.000+08:00

今天发现从utf8到shift-jis转换。
〜和～，这两个波浪线是有区别的。前者可以转成shift-jis的～，而后者会出现乱码。
真是麻烦的编码呀。

用反向代理访问catalyst时的问题

2006-12-08T15:26:00.000+08:00

由于测试需要，catalyst的服务器前有两个反向代理，像这样：

user->A->B->Catalyst Server

这样的结构当使用uri_for的时候，拼接出来的url可能就会变成“http://A,%20B/....”。这是因为catalyst从apache的X-Forwarded-Host中（Catalyst/Engine/Apache.pm）得到真正的地址，而通过两次代理之后，这个变量中存了A和B的地址。因此会出现这种情况。

另外这个pm中也可以看到，用代理的时候，如果不改cayalyst的代码，前端的端口只能用80或443，否则uri_for这种内部生成url的函数都不会生成正确的端口。

Total Commander

2006-12-01T23:07:00.000+08:00

smth版上组织TC的团购，一个许可150，想想也不算太贵，于是买了一个。今天终于收到key了，小小激动一把。

自从工作之后，受到环境的影响，用软件渐渐向免费的靠拢。有个同事号称freeware master，我虽然还不能达到那种境界，但基本上都换成了免费的。像写文档用openoffice，写程序用emacs，画图用gimp，杀毒用AVG，解压缩用7zip，辞典用stardict（这个好像辞典开始收费了，准备快成lingoes了）。但TC这个用了一次之后就每次开机都常驻的软件却始终找不到一个好的替代品，趁这个机会也就向作者贡献了一下。