He Xiong's BLOG in Google

常用正则表达式

2012-03-18T23:50:00.002-07:00

正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。

用户名：/^[a-z0-9_-]{3,16}$/

密码：/^[a-z0-9_-]{6,18}$/

十六进制值：/^#?([a-f0-9]{6}|[a-f0-9]{3})$/

电子邮箱：/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/

URL：/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/

IP 地址：/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/

HTML 标签：/^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$/

Unicode编码中的汉字范围：/^[u4e00-u9fa5],{0,}$/

匹配中文字符的正则表达式： [\u4e00-\u9fa5]
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了

匹配双字节字符(包括汉字在内)：[^\x00-\xff]
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

匹配空白行的正则表达式：\n\s*\r
评注：可以用来删除空白行

匹配HTML标记的正则表达式：<(\S*?)[^>]*>.*?</\1>|<.*? />
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力

匹配首尾空白字符的正则表达式：^\s*|\s*$
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式

匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
评注：表单验证时很实用

匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*
评注：网上流传的版本功能很有限，上面这个基本可以满足需求

匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
评注：表单验证时很实用

匹配国内电话号码：\d{3}-\d{8}|\d{4}-\d{7}
评注：匹配形式如 0511-4405222 或 021-87888822

匹配腾讯QQ号：[1-9][0-9]{4,}
评注：腾讯QQ号从10000开始

匹配中国大陆邮政编码：[1-9]\d{5}(?!\d)
评注：中国大陆邮政编码为6位数字

匹配身份证：\d{15}|\d{18}
评注：中国大陆的身份证为15位或18位

匹配ip地址：\d+\.\d+\.\d+\.\d+
评注：提取ip地址时有用

匹配特定数字：
^[1-9]\d*$　　 //匹配正整数
^-[1-9]\d*$ 　 //匹配负整数
^-?[1-9]\d*$　　 //匹配整数
^[1-9]\d*|0$　 //匹配非负整数（正整数 + 0）
^-[1-9]\d*|0$　　 //匹配非正整数（负整数 + 0）
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$　　 //匹配正浮点数
^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$　 //匹配负浮点数
^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$　 //匹配浮点数
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$　　 //匹配非负浮点数（正浮点数 + 0）
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$　　//匹配非正浮点数（负浮点数 + 0）
评注：处理大量数据时有用，具体应用时注意修正

匹配特定字符串：
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
^\w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串

表达式全集

正则表达式有多种不同的风格。下表是在PCRE中元字符及其在正则表达式上下文中的行为的一个完整列表：

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“`n`”匹配字符“`n`”。“`\n`”匹配一个换行符。序列“`\\`”匹配“`\`”而“`\(`”则匹配“`(`”。
^	匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“`\n`”或“`\r`”之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“`\n`”或“`\r`”之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo能匹配“`z`”以及“`zoo`”。等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，“`zo+`”能匹配“`zo`”以及“`zoo`”，但不能匹配“`z`”。+等价于{1,}。
?	匹配前面的子表达式零次或一次。例如，“`do(es)?`”可以匹配“`do`”或“`does`”中的“`do`”。?等价于{0,1}。
{n}	n是一个非负整数。匹配确定的n次。例如，“`o{2}`”不能匹配“`Bob`”中的“`o`”，但是能匹配“`food`”中的两个o。
{n,}	n是一个非负整数。至少匹配n次。例如，“`o{2,}`”不能匹配“`Bob`”中的“`o`”，但能匹配“`foooood`”中的所有o。“`o{1,}`”等价于“`o+`”。“`o{0,}`”则等价于“`o*`”。
{n,m}	m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“`o{1,3}`”将匹配“`fooooood`”中的前三个o。“`o{0,1}`”等价于“`o?`”。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“`oooo`”，“`o+?`”将匹配单个“`o`”，而“`o+`”将匹配所有“`o`”。
.	匹配除“`\n`”之外的任何单个字符。要匹配包括“`\n`”在内的任何字符，请使用像“`[.\n]`”的模式。
(pattern)	匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“`$`”或“`$`”。
(?:pattern)	匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用或字符“`(\|)`”来组合一个模式的各个部分是很有用。例如“`industr(?:y\|ies)`”就是一个比“`industry\|industries`”更简略的表达式。
(?=pattern)	正向预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“`Windows(?=95\|98\|NT\|2000)`”能匹配“`Windows2000`”中的“`Windows`”，但不能匹配“`Windows3.1`”中的“`Windows`”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	负向预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如“`Windows(?!95\|98\|NT\|2000)`”能匹配“`Windows3.1`”中的“`Windows`”，但不能匹配“`Windows2000`”中的“`Windows`”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
x\|y	匹配x或y。例如，“`z\|food`”能匹配“`z`”或“`food`”。“`(z\|f)ood`”则匹配“`zood`”或“`food`”。
[xyz]	字符集合。匹配所包含的任意一个字符。例如，“`[abc]`”可以匹配“`plain`”中的“`a`”。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如，“`[^abc]`”可以匹配“`plain`”中的“`p`”。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，“`[a-z]`”可以匹配“`a`”到“`z`”范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，“`[^a-z]`”可以匹配任何不在“`a`”到“`z`”范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如，“`er\b`”可以匹配“`never`”中的“`er`”，但不能匹配“`verb`”中的“`er`”。
\B	匹配非单词边界。“`er\B`”能匹配“`verb`”中的“`er`”，但不能匹配“`never`”中的“`er`”。
\cx	匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“`c`”字符。
\d	匹配一个数字字符。等价于[0-9]。
\D	匹配一个非数字字符。等价于[^0-9]。
\f	匹配一个换页符。等价于\x0c和\cL。
\n	匹配一个换行符。等价于\x0a和\cJ。
\r	匹配一个回车符。等价于\x0d和\cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于[\f\n\r\t\v]。
\S	匹配任何非空白字符。等价于[^\f\n\r\t\v]。
\t	匹配一个制表符。等价于\x09和\cI。
\v	匹配一个垂直制表符。等价于\x0b和\cK。
\w	匹配包括下划线的任何单词字符。等价于“`[A-Za-z0-9_]`”。
\W	匹配任何非单词字符。等价于“`[^A-Za-z0-9_]`”。
\xn	匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“`\x41`”匹配“`A`”。“`\x041`”则等价于“`\x04&1`”。正则表达式中可以使用ASCII编码。.
\num	匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“`(.)\1`”匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字（0-7），则n为一个八进制转义值。
\nm	标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式，则nm为向后引用。如果\nm之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字（0-7），则\nm将匹配八进制转义值nm。
\nml	如果n为八进制数字（0-3），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。
\un	匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9匹配版权符号（?）。

以下是以PHP的语法所写的示例

验证字符串是否只含数字与英文，字符串长度并在4~16个字符之间

<?php
$str = 'a1234';
if (preg_match("^[a-zA-Z0-9]{4,16}$", $str)) {
    echo "驗證成功";
} else {
    echo "驗證失敗";
}
?>

简易的台湾身份证字号验证

<?php
$str = 'a1234';
if (preg_match("/^\w[12]\d{8}$/", $str)) {
    echo "驗證成功";
} else {
    echo "驗證失敗";
}
?>

以下示例是用 Perl 语言写的，与上面的示例功能相同

print $str = "a1234" =~ m:^[a-zA-Z0-9]{4,16}$: ? "COMFIRM" : "FAILED";

print $str = "a1234" =~ m"^\w[12]\d{8}$" ? "COMFIRM" : "INVAILD";

如何写出高效率的正则表达式

如果纯粹是为了挑战自己的正则水平，用来实现一些特效（例如使用正则表达式计算质数、解线性方程），效率不是问题；如果所写的正则表达式只是为了满足一两次、几十次的运行，优化与否区别也不太大。但是，如果所写的正则表达式会百万次、千万次地运行，效率就是很大的问题了。我这里总结了几条提升正则表达式运行效率的经验（工作中学到的，看书学来的，自己的体会），贴在这里。如果您有其它的经验而这里没有提及，欢迎赐教。

为行文方便，先定义两个概念。

误匹配：指正则表达式所匹配的内容范围超出了所需要范围，有些文本明明不符合要求，但是被所写的正则式“击中了”。例如，如果使用\d{11}来匹配11位的手机号，\d{11}不单能匹配正确的手机号，它还会匹配98765432100这样的明显不是手机号的字符串。我们把这样的匹配称之为误匹配。

漏匹配：指正则表达式所匹配的内容所规定的范围太狭窄，有些文本确实是所需要的，但是所写的正则没有将这种情况囊括在内。例如，使用\d{18}来匹配18位的身份证号码，就会漏掉结尾是字母X的情况。

写出一条正则表达式，既可能只出现误匹配（条件写得极宽松，其范围大于目标文本），也可能只出现漏匹配（只描述了目标文本中多种情况种的一种），还可能既有误匹配又有漏匹配。例如，使用\w+\.com来匹配.com结尾的域名，既会误匹配abc_.com这样的字串（合法的域名中不含下划线，\w包含了下划线这种情况），又会漏掉ab-c.com这样的域名（合法域名中可以含中划线，但是\w不匹配中划线）。

精准的正则表达式意味着既无误匹配且无漏匹配。当然，现实中存在这样的情况：只能看到有限数量的文本，根据这些文本写规则，但是这些规则将会用到海量的文本中。这种情况下，尽可能地（如果不是完全地）消除误匹配以及漏匹配，并提升运行效率，就是我们的目标。本文所提出的经验，主要是针对这种情况。

掌握语法细节。正则表达式在各种语言中，其语法大致相同，细节各有千秋。明确所使用语言的正则的语法的细节，是写出正确、高效正则表达式的基础。例如，perl中与\w等效的匹配范围是[a-zA-Z0-9_]；perl正则式不支持肯定逆序环视中使用可变的重复（variable repetition inside lookbehind，例如(?<=.*)abc），但是.Net语法是支持这一特性的；又如，JavaScript连逆序环视（Lookbehind,如(?<=ab)c）都不支持，而perl和python是支持的。《精通正则表达式》第3章《正则表达式的特性和流派概览》明确地列出了各大派系正则的异同，这篇文章也简要地列出了几种常用语言、工具中正则的比较。对于具体使用者而言，至少应该详细了解正在使用的那种工作语言里正则的语法细节。

先粗后精，先加后减。使用正则表达式语法对于目标文本进行描述和界定，可以像画素描一样，先大致勾勒出框架，再逐步在局步实现细节。仍举刚才的手机号的例子，先界定\d{11}，总不会错；再细化为1[358]\d{9}，就向前迈了一大步（至于第二位是不是3、5、8，这里无意深究，只举这样一个例子，说明逐步细化的过程）。这样做的目的是先消除漏匹配（刚开始先尽可能多地匹配，做加法），然后再一点一点地消除误匹配（做减法）。这样有先有后，在考虑时才不易出错，从而向“不误不漏”这个目标迈进。

留有余地。所能看到的文本sample是有限的，而待匹配检验的文本是海量的，暂时不可见的。对于这样的情况，在写正则表达式时要跳出所能见到的文本的圈子，开拓思路，作出“战略性前瞻”。例如，经常收到这样的垃圾短信：“发*票”、“发#漂”。如果要写规则屏蔽这样烦人的垃圾短信，不但要能写出可以匹配当前文本的正则表达式发[*#](?:票|漂)，还要能够想到发.(?:票|漂|飘)之类可能出现的“变种”。这在具体的领域或许会有针对性的规则，不多言。这样做的目的是消除漏匹配，延长正则表达式的生命周期。

明确。具体说来，就是谨慎用点号这样的元字符，尽可能不用星号和加号这样的任意量词。只要能确定范围的，例如\w，就不要用点号；只要能够预测重复次数的，就不要用任意量词。例如，写析取twitter消息的脚本，假设一条消息的xml正文部分结构是…且正文中无尖括号，那么[^<]{1,480}这种写法的思路要好于.*，原因有二：一是使用[^<]，它保证了文本的范围不会超出下一个小于号所在的位置；二是明确长度范围，{1,480}，其依据是一条twitter消息大致能的字符长度范围。当然，480这个长度是否正确还可推敲，但是这种思路是值得借鉴的。说得狠一点，“滥用点号、星号和加号是不环保、不负责任的做法”。

不要让稻草压死骆驼。每使用一个普通括号()而不是非捕获型括号(?:…)，就会保留一部分内存等着你再次访问。这样的正则表达式、无限次地运行次数，无异于一根根稻草的堆加，终于能将骆驼压死。养成合理使用(?:…)括号的习惯。

宁简勿繁。将一条复杂的正则表达式拆分为两条或多条简单的正则表达式，编程难度会降低，运行效率会提升。例如用来消除行首和行尾空白字符的正则表达式s/^\s+|\s+$//g;，其运行效率理论上要低于s/^\s+//g; s/\s+$//g; 。这个例子出自《精通正则表达式》第五章，书中对它的评论是“它几乎总是最快的，而且显然最容易理解”。既快又容易理解，何乐而不为？工作中我们还有其它的理由要将C==(A|B)这样的正则表达式拆为A和B两条表达式分别执行。例如，虽然A和B这两种情况只要有一种能够击中所需要的文本模式就会成功匹配，但是如果只要有一条子表达式（例如A）会产生误匹配，那么不论其它的子表达式（例如B）效率如何之高，范围如何精准，C的总体精准度也会因A而受到影响。

巧妙定位。有时候，我们需要匹配的the，是作为单词的the（两边有空格），而不是作为单词一部分的t-h-e的有序排列（例如together中的the）。在适当的时候用上^，$，\b等等定位锚点，能有效提升找到成功匹配、淘汰不成功匹配的效率。

DB2 v9.5在Ubuntu10.x下安装

2012-03-11T18:30:00.000-07:00

以前用的是Ubuntu9.0.4，装DB2 v9.5非常轻松，一路下去，什么问题也没有。

这次情况不妙，Ubuntu升级到10.04以后，缺了libstdc++.so.5，系统中只有.so.6，

使用apt-get intall libstdc++5，也找不到安装包。无奈，只能在网上苦苦搜索，找了半天也没找到可下载的源。

最后在http://ishare.iask.sina.com.cn/f/14409917.html?retcode=0 上找到一个。

再补充后边的几个步骤：

1. dpkg -x libstdc++5_3.3.6-10_i386.deb libstdc++5

cd libstdc++5/usr/lib

mv * /usr/lib

结果如下：

root@linux11:/usr/lib# ls -al libstdc++*lrwxrwxrwx 1 root root 18 2010-12-09 11:54 libstdc++.so.5 -> libstdc++.so.5.0.7
-rw-r--r-- 1 root root 737496 2005-10-26 20:25 libstdc++.so.5.0.7
lrwxrwxrwx 1 root root 19 2010-11-26 00:02 libstdc++.so.6 -> libstdc++.so.6.0.14
-rw-r--r-- 1 root root 930044 2010-09-28 05:01 libstdc++.so.6.0.14

补充安装gcc-3.3-base和openssh, rsh-server:

wget -c http://free.nchc.org.tw/ubuntu//pool/universe/g/gcc-3.3/gcc-3.3-base_3.3.6-15ubuntu4_i386.deb

dpkg -i gcc-3.3-base_3.3.6-15ubuntu4_i386.deb

apt-get install openssh-server

export DB2USELOCALJRE=yes

3. 运行db2setup开始安装，选择install a Product，进入DB2 Setup Wizard

后边基本上不会碰到什么问题。

Oracle11.2.0非安装版(简装版)制作完成(仅供开发人员参考使用)

2012-03-11T18:27:00.002-07:00

作者: iihero@CSDN, 2012.3.11. 请尊重个人劳动。如若转载，请注明原始出处。Thanks.

下载地址:

http://download.csdn.net/detail/iihero/4131001

(免责声明):
这是一个精简版的oracle11g for windows 32bit x86平台.
此压缩包，仅供学习研究使用，本文作者不负任何责任。适合于开发人员使用。切不可将其用于商业用途，请遵守
Oracle公司相关商业规定。如因私自将其用于商业用途，由此带来的法律纠纷或其它问题，概与本人无关.
author: iihero@CSDN (iiihero AT hotmail.com; iihero AT qq.com)

0. 如果你已经安装了别的版本的oracle，
请自行备份注册表:[HKEY_LOCAL_MACHINE/SOFTWARE/ORACLE], 这样即算有冲突，
你也可以重新导入以前的注册项而得已恢复

1. 将压缩包解压至目录，设该目录值为: d:\,
其下将有目录：
<D>/oracle/*
<D>/oracle/11.2.0

2. 新的ORACLE_HOME将为：<D>/oracle/11.2.0
运行完iihero.ora11g.bat运行完以后，(一个批处理一次安装全部完成)
你需要将<D>/oracle/11.2.0/BIN添加到path里头
缺省的ORACLE_SID为iihero，你可以自行修改iihero.ora11g.bat中的SID值，不要超过8个字符。

3. 安装完以后，别忘了添加环境变量ORACLE_SID=iihero以及将%ORACLE_HOME%/bin
添加到PATH环境变量里头，在这之后，
即可使用sqlplus system/manager进入并修改密码，执行表空间、用户管理相关操作。
如：

[sql]view plaincopy

D:\Oracle>sqlplus system/manager  
  
SQL*Plus: Release 11.2.0.1.0 Production on 星期日 3月 11 13:14:35 2012  
  
Copyright (c) 1982, 2010, Oracle.  All rights reserved.  
  
  
连接到:  
Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - Production  
With the Partitioning, OLAP, Data Mining and Real Application Testing options  
  
SQL> quit  
从 Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - Production  
With the Partitioning, OLAP, Data Mining and Real Application Testing options 断开  

欢迎大家试用，如果发现有什么问题，可以与本人联系。

这个11g的包，既可充当server，同时也可以用作oci, jdbc,sqlplus,odbc等的客户端工具。还是比较齐全的。
11g比10g的非安装包，确实大了不少。10g的时候，总共才50M不到，这不，到了11g，压缩完以后，也有100来兆。不过，不管怎样，比原始的安装包，那可是小了很多了。

10g的非安装包，详见我以前的文章：

http://blog.csdn.net/iihero/article/details/5632260

九州出版社征稿合作(长期有效)

2012-03-06T16:17:00.002-08:00

征稿范围：
自费出书要求：一书一号管理费15000元, 稿件应该符合出版“齐、清、定”的要求，必须政治方向正确，不得抄袭。
非常欢迎自费出版文史哲或社科论文集的和我联系。量大有优惠。

联系方式：

地址：北京市西城区阜城门外大街甲35号九州出版社
邮编：100037

电话：131 4610 2875
周编辑 (周老师)

qq: 35824648
邮箱：spring.zhou@qq.com

九州出版社是中央级综合性出版社，以弘扬中华文化、促进海峡两岸文化交流为宗旨，出版社会科学、自然科学、文学和艺术方面的图书、画报和画册。是国内最具规模和权威的跨越两岸学术文化出版基地。2009年被新闻出版总署评为国家一级出版社，授予“全国百佳图书出版单位”荣誉称号。

九州出版社将设立出版基金，并面向社会诚征书稿，以更加灵活的出版方式，高质量服务于两岸读者，为繁荣包括两岸在内的中国出版事业添柴加薪。

业余乒乓球手的答疑总结

2012-03-05T21:11:00.001-08:00

问：我是成年人，以前打球有几年的时间，不好的动作定型了，还能改过来吗？

答：成年人由于以前打球把动作打定型了，要想改动作的确是比较困难的，因为肌肉发力活动已经形成了较为深刻的"记忆"，如果要改动作，那么这种新的"肌肉记忆"必须用大脑来想着做，等上台打球的时候注意力又要集中在盯球上，这样就变成"一心二用"，精力容易疲惫，从而造成动作与手感脱节打不到球。
我们说成年人动作不容易改，但是要通过练习调整得相对发力合理却是很容易的，这时候只要能够找到一个熟悉的发力参照对象，那么肌肉就有了这种参照发力记忆，这时候再上台打球就可以集中精力在盯球环节上了，通过一段时间练习，就可以改掉以前不正确的发力方式。

问：我打反胶老是吃别人的旋转怎么办？能不能改用长胶或生胶，应该怎么练？

答：很多球友在比赛的时候都有这个问题，吃发球，吃转，老是处理不好，无奈之下想到换用颗粒胶以减轻吃转的摩擦，殊不知有得必有失，颗粒胶旋转弱了，相对来说控制难度也就增大了，正所谓欲伤人，先伤己，要想打好颗粒胶，自己难受在先，等自己习惯了，才轮到别人难受。
所以我们说首先要明确你打球的目的是什么，是要健身，还是娱乐，还是纯粹为了比赛？从反胶换到颗粒胶，开始是很不容易感受到打乒乓球的乐趣的，因为长胶和生胶回过来的球有反旋转，球路不同，动作也不一样；同样，别人打得难受了，也就不太愿意和你练，所以这也是颗粒胶难练好的一个重要的因素。而打反胶只要有正确的方法，就可以学会接发球的原理，明白了旋转的原理，自然就会调整拍型去适应各式各样的旋转，这其实也是乒乓球最大的乐趣之一。
要练好颗粒胶，如长胶，其实也不是没有办法，除了找教练以外，还可以找想和长胶练习以适应长胶的球友。只要能找到一个合适的球友，两人可以通过攻防磕搓这种有规律的转换方式来练习，具体方法是：反胶发球，长胶磕过来为下旋，反胶搓，然后长胶攻（拱或者挑打），反胶防一板过去，长胶再磕一板下旋...如此反复练习；这也是长胶打比赛最基本的规律，同时反胶要想适应长胶，这也是最基本的方法。

问：我打球有一段时间状态特别好，有时候却又老是没有状态，球友都说这是要涨球（进步）的表现，这是怎么回事啊？

答：练习乒乓球技术，其进步是螺旋式或者说波浪式上升的，也就是说在球技上涨到一定程度的时候状态会有所"下滑"，回落到一个"状态低谷期"，这是很正常的表现，这个"低谷期"也就是我们常说的"瓶颈期"，只要能克服这个瓶颈期，那么我们的球技又会达到一个新的提升空间。

那么"瓶颈期"是怎么产生的呢？我们在练球的期间肯定是要通过不断地比赛才能把平时练的这些技术融汇到比赛中去，形成各种战术。那么我们知道，练球给的是定点，或者是有规律的变化落点，哪怕是不定点练习所给的球也是力度、弧线基本没有太大变化的；而比赛的时候两人都是想方设法地去变化，去控制对方，然后抓住机会给予致命一击。这样完全不同的打球方式就会对我们打乒乓球的一个最基本的要素――节奏感――造成影响，打比赛的期间越长，对节奏感的影响也就越大，等到量变积累到一定程度以后，就会形成质变，这样你混乱的节奏感就会突然爆发出来，造成状态低迷，打球找不到"点"。

每个人在练球比赛的过程中都会有"瓶颈期"，在初学到提高这个阶段，"瓶颈期"不会很明显，而在提高阶段"瓶颈期"是最明显的，也是最容易频繁出现的，要想快速度过"瓶颈期"，就需要用正确的方法来练球，把动作、节奏感调整回来，逐渐地，越到后来"瓶颈期"的间隔时间也就会越长，而持续时间也会变得越短。

问：我练球也有几次了，为什么和别人打球的时候动作还是改不过来，始终是原来的动作？
答：这个问题也是许多正在改动作的成年人的疑惑之处，为什么练球的时候动作很好，而一打起比赛来就被"打回原形"呢？

前面我们曾经说过，练球给的是定点，或者是有规律的变化落点；而比赛的时候两人都是想方设法地去变化，去控制对方，这样不定点的球想要打上台，注意力就必须高度集中在盯球上，而此时新改的动作还没能够形成较为深刻的肌肉记忆（用俗话说就是还没练到家），因此出手的时候自然会变回以前的下意识动作，这个时候比赛和练球两者间会造成一个矛盾效应，互相影响。

所以我们在给初学者练球以固定动作的时候，一般是不提倡他们打比赛的，因为这样会对练球的效果产生负面影响。我们一般建议许多初学者如果在时间允许的情况下，尽可能地经常练球，训练密度大一些，就越容易在较短的时间内把动作固定下来，等自身技术达到一定的条件之后，我们就会建议初学者去和水平相当的球友打比赛，以便把练球的动作融汇到比赛中去。
而对于以前不合理动作定型的学球者来说，我们的建议同样和对初学者差不多，刚开始改动作的时候尽量少打比赛，并且在时间允许的情况下增大训练密度，在训练完了以后可以适当地打一下比赛（最好和水平比自己弱的打，这样对方的控制能力不会太强，不容易造成你的动作变形），尽可能地把新练习的发力方式转化为下意识的肌肉记忆，这样才能逐渐把以前不合理的动作改正过来。

问：我的发球为什么发不出强烈的旋转？

答：大家跟发球好的球友过招，都能感觉到对方发的转球旋转特别强烈，很容易直接吃发球，郁闷之余也会经常琢磨一下自己怎么也能发出这样旋转强烈的球，但是往往尝试过若干次之后还是不得要领。下面我就介绍发强旋转球需要注意的三个最基本的因素。

一、非持拍手的抛球
发球靠持拍手，但大家往往忽略了非持拍手的抛球动作。能否发出好球，首先取决于非持拍手抛球的弧线位置是否能让持拍手击球很舒服，发得出力来，如果连最基本的力度都使不出来，那你再怎么找摩擦的感觉也是徒劳的。
刚开始练习的时候，许多初学者往往怕身子挡到持拍手，都会面向前，把球抛到自己的前方或侧前方，这样持拍手是无法发足力的，正确的方法应该是侧向站位（右手持拍者站于球台的左侧，左脚在前，右脚在后），抛球于自己身体偏右的位置（右手为例），而一些高手抛球甚至还要靠后，这样更利于逆旋转发球加力，就好像弓拉得越满，力度越足。

二、引拍动作以及球拍摩擦球体时的切入角度
先说引拍动作，很多球友发球使不出力度，除了抛球的位置不好之外，就是引拍的距离太短，正所谓拉弓射箭，弓都不拉开哪里来射箭的力度呢？这时候要注意适当地增加引拍弧度，刚开始靠小臂带动手腕发力，手腕要放松，逐渐地还要学会带上一点腰的转动。
其次，摩擦切入角度是最重要的，摩擦吃球的"厚"与"薄"指的就是拍型接触球一瞬间的力度方向切入球体的角度，切入越厚，那么力度轴越靠近球中心，那么这时候球体得的撞击力越多，速度也就越快；反之，摩擦越薄，球体旋转就越强。
直观一点来举个例子，球拍正面与球台夹角，90度为垂直，180度为平行，比如发下旋球，130度夹角摩擦出来的球和放平球拍摩擦出来的球，哪个转？那么有的球友就问了，放平了擦不到球啊，当然，球拍放得越平，相对触球面积也就越小，这时候要想提高击球的精准性，就进入下面第三点。

三、发球节奏
乒乓球的控制、进攻都是靠节奏的变化来掌握的，发球也不例外，从抛球到下落这个时间段，节奏感决定了你的摩擦精准度。许多初学者刚开始练习发球的时候，都是用眼睛去"瞄"，看球落下来差不多了，就出手去碰，这样造成什么问题？注意力集中在球下落的过程中，就不可能去找摩擦的厚薄感了，精确性大打折扣。所以什么时候该出手，要靠节奏感来掌握，凭感觉去判断出手时机，第一次失误了，分析一下是出手早了还是晚了，下次再调整节奏，慢慢地，你的发球精准度就会提高。

PS一个练习发球的小技巧：在家里的床单上练习发球，找摩擦的感觉，如果力度足，摩擦得好，球落到床单上以后就会有强烈的旋转，如果是下旋球就会马上向后窜。这样练习的好处就是不用经常去捡球，只需要一个球就可以，而且旋转强度可以立马看出来，待找到摩擦手感后，再去球台上练习，调整力度落点。

问：练习正手攻球的时候总是腿、腰和手脱节怎么办？

答：练习正手攻球回合的时候讲究腰腿配合，这是进一步发力的基础，业余爱好者如果经过很长时间的练习还是不能做到很协调地"重心蹬转-转腰带手"的话，除了练习方法问题以外，就是自身协调能力比较差了。

首先要说的一点是练习方法的问题，通过观看技术动作图片、教学视频，大家能把动作模仿到大致相似的程度，但是乒乓球是非常细节化的一项运动，要求在身体协调的情况下还要找准节奏、击球点、击球位置等，不像学舞蹈，动作到位好看了就行。在练习正手攻球的时候很多成年人身体协调不起来，是因为思想的"分心"导致动作和球感脱节，为什么这么说呢？你想，你原先的动作仅限于手上，那么这时候你只需要控制手去击球就可以，假如突然让你蹬腿、转腰，还要用腰带着手去迎前击球，你一心N用，注意力还怎么集中在盯球环节上呢？这时候势必造成你想着腿就忘了腰，想着球就忘了蹬地，一环脱节，动作全散。

因此，要做到所谓的"动力定型"，最好的方法就是找到一个平日最熟悉的、和攻球发力相似的动作，在这种参照动力的作用下，相信你就比较容易把注意力放在盯球环节上而不会"分心"了，那么这个动作可以有好几种：泼水、甩包、挥铁拍等。物体虽然不同，但是都有一个特点，就是重量增加了很多，这时候要发上力，如果只用手那可是费力不讨好哦！在这种重量下，蹬地转腰带手自然而然会成为最合理、最轻松的发力方式。假如换回重量轻的球拍后还能把它想象成重的东西，手臂自然就能够放松了。

当然上面说的仅仅是相近似的发力方式，具体的动作准确度还需要教练指导或者自己再进一步固定。如果在重心蹬转环节练习过程中，有重心交换，转腰到位的话，有一个简单的方法可以证明出来，我称之为"单摆效应"。就是说，当你脖子上挂上一个吊坠，形成一个可以甩动的单摆(当然挂绳要稍微长一点，20多厘米吧，这样吊坠垂下正好在胸前)，在反复做重心交换带转腰这个动作时，只要频率均匀，挂着的吊坠就会慢慢左右摆动，继而向两边"甩"动，打在两肩上。

如果不会出现这种情况的话，就是有蹬无转，或者有转无蹬。因为当只有重心蹬过来蹬过去而没有转腰时，吊坠只会左右摆，而不会出现"甩"起来打在两边肩头上的情况；而只有转腰无重心交换时（有些人做这个动作就像在扭转盘那样）吊坠也是不容易两边甩打起来。当然如果腰髋同转的话也能形成"单摆效应"，不过这样在桌前练习进台正手攻球时会觉得腿部很费力。

问：为什么有的人练球后比赛能力提高很快，有的人总是不能很好地把练习和实战结合起来？

答：练习和实战的有机结合无疑是乒乓球训练内容里难度最大的一个环节，无论是小孩还是成年人，一般刚开始练习基本功的时候都是从正手攻球、反手拨球、正反手转换、搓球、高吊起下旋、起下旋后转为上旋连续推拨攻这些技术练起，这些基本技术熟练后再加上一个合适的发球技术，基本就具备了进行简单比赛的能力，而相对来说小孩的训练还更要系统些，要多包括两点走位、三点走位、侧身走位扑正手等涵盖步法的练习。

在练习的过程中由于各人的先天意识（天分）差异会产生两种练习效果，一种是主动练习，一种是被动练习。一些球友经过这些相对系统的练习以后球技提升得很快，就属于前者；而大多数球友系统练习了很长时间但实战能力仍然得不到质的提高，这就是因为在练球的时候思维意识不够"主动"。这里所说的"主动"，并不是简单地指你练球的态度是否积极，而是包含了在练球细节中的"调控意识"和"潜意识记忆能力"。

"调控意识"指的是在多回合练习一个单项技术中，对来球弧线落点微小差别的判断能力，以及自己回球弧线落点的微调控制能力。调控意识强的球友在一个单项技术练习了多回合以后能够注意到每个回球很细微的弧线落点变化，进而不断微调，逐渐把回球节奏感和手感定得很精确，一旦达到一定要求后，马上又可以加强回合频率、速度等进一步提升；而调控意识弱的球友在练习某一单项技术时，往往就成了"死练"，在多回合的练习过程中仅仅注意到上台、不失误、练得舒服等，成了"应付式"练习，而不会去主动观察、微调整回球的弧线落点进而进一步加强节奏感手感的精确性，这样他们所表现出来最明显的一个现象就是只会和教练、控球好的球友或者一起练得很熟的人练球，而换一个人（也具有同样的练球能力）以后就对不上点，练不起多回合来了，至少是不能马上相互适应。

"潜意识记忆能力"则体现在技战术结合练习以及和实战结合练习中，这种潜意识记忆能力好的球友能够举一反三，俗话说叫做"长记性"，比如练习搓中拉高吊，要素有放松腰腿发力、摩擦厚薄、击球点等，在一段练习过程中一旦他找准了整体感觉，对于逐渐加强一些难度或者有变化的回搓球也能够很好地去调整，他能够在有一定变化的回球中找准拉球成功的若干"要素"，即使失误了也能够马上下意识想到是哪一点出了问题，是不够放松而没力度还是击球太厚等；而记忆能力差的球友就吃亏了，同样经过一段时间练习，低难度练习能够拉得好，难度稍高些拉球质量就下降，再稍微有些变化就不会拉球了，而最关键的是他自己搞不清楚是哪一个要素出了问题导致失误。这一"长不长记性"的能力差别就造成日后你的比赛能力能够有多大提高。

问：我拉下旋球总是失误，比赛的时候不敢上手，如何解决这个问题？

答：拉下旋球技术相对于攻球技术来说，难度要大一些，因为要自身主动发力，所以很多初学者在刚开始练习起下旋的时候往往整个身子会很僵硬，这是由于正手攻球基本功练习不到位的缘故，需要弥补。刚开始练习拉下旋，一般都是从拉高吊弧圈球开始，这里需要注意三个要素：1.发力；2.引拍击球节奏；3.摩擦点和厚薄比例。三个要素都具备了，起下旋就会很轻松，某个要素没做好就容易失误。

1.发力是拉球的基础，这里所说的发力不是发死力、发蛮力，而是全身发力的顺畅和集中，如果发力方式不合理，球拍在空中运行的加速度就出不来，自然也就无法拉起下旋球来。

2.这一点包含了两个方面，引拍的时机和出拍击球的时机。和正手攻球一样，引拍要在对手击球（搓球）后球过来的一瞬间开始，这个节奏过早则造成"等球"，等了以后就只能用眼睛去瞄，出手时机就不准确，过晚则会被来球顶住发不出力；出手时机需要找准来球的弧线顶点，这时候球会"定住"一瞬间然后开始下降，此时出手命中率最高，如果抢点过早，在来球上升期就出手拉球则容易失误。这一点综合起来看，整体的动作就是球过来瞬间开始引拍-到位-找准击球点马上出手，这个动作需要一气呵成，每个环节都不能有明显停顿，否则就会影响拉球质量。

3.这一点也包含了两个方面，摩擦球上的位置和摩擦厚薄。摩擦球上的位置位于球体中上部或者中部，而且要"正"，如果摩擦位置偏了则拉下旋球的上升力度也会由于角度偏斜而减弱从而造成下网。那么从动作上看，一些初学者拉球时手腕习惯"勾"着，内扣太多，这样一拉球摩擦点总是偏到侧面，难怪使很大的劲还是感觉球容易往下掉，这时候一定要把手腕外撇开，拍型适当前倾，在身体前面击球，这样才能发上力。摩擦厚薄可以通过听击球响声来判断，俗话说"响球不转，转球不响"，就是这个道理。击球太厚，则会听到很脆的"啪"声，弧线不好，不容易上台，这时候要增加吃球的摩擦，也就是薄一些，就能够纠正这个问题了。

上面所说的是练习拉下旋时的注意事项，而在比赛中，如果要想上手拉起下旋球，那么首先要过了对方的控球关，也就是说，在搓球控制上的能力必须高于对手或和对手差不多，这样才能通过搓球控制迫使对方出现低质量的回球，自己才有机会上手。否则对方搓过来的下旋球都是弧线又低、又顶又快、落点又偏的高质量，你又如何能够保证自己的上手质量？所以在练习中学会拉下旋以后，应该先和控球水平低于自己的球友打练习比赛，在"菜鸟"身上找准感觉，这样才能够尽快把练习和比赛结合起来。很多人认为必须和高手过招才会有进步，和菜鸟打只会越打越差的观点是很片面的。

问：球在起跳飞行的不同时期旋转会有变化吗？为什么会说高吊弧圈球上升期旋转还没出来所以容易打，而到了高点以后旋转就出来所以不好打了？球擦网后旋转如何变化？

答：从物理角度来分析，球在飞行过程中会受到空气的阻力，接触到台面以后也会受到一个来自台面的摩擦力。球体产生旋转，是靠球拍胶皮给予的一个摩擦力所作用的结果，而空气阻力在球体飞行过程中所起到减弱球体旋转的持续效果是很小的，可以忽略，所以不会出现很明显的"由强变弱"这种感觉，更不会有"由弱变强"这种现象。

有些人说快攻打高吊弧圈球在上升期打容易，而到高点以后球的旋转出来就不好打了，因为在上升期击打容易上台，而在高点期后触球就会感觉压不住球的旋转，所以就有一种"直观"上的说法，认为球起跳到高点以后旋转会变得更"强"。实际上这是一种感觉上的误差，因为旋转是不会有很明显变化的，而明显变化的环节在于球体的行进动能上，也就是上升前冲力的减弱程度上，在高点以后因为借不到球体的上升力度而无法产生足够的"合力"把球的弧线压下来。

在拉下旋球的时候，最佳击球点是在弧线的顶点期至下降前期，这时候难度最低，如果是在上升期拉下旋球，由于球体上升时带有的动能冲量较多，就容易造成击球摩擦过厚，而不好控制回球弧线。对于擦网球来说，会感到旋转变化比较明显，这里面也有一个节奏变化和球体前冲力变化的因素影响。比如下旋球擦网以后球体的旋转会因球体底部受到网带的阻力而减弱，这一点会搓球的球友应该都有体会。

而拉球时如果擦网比较重的话，最明显的一个感觉是球一下就定住不往前走了，而这时候迎上去击球往往会压不住球的旋转，一碰就飞，感觉旋转变强了好多。对于这一点，我感觉球的旋转强度应该是会有所增加的，因为上旋球球体在前冲的过程中被球网截了一下底部后，一部分前冲动能会损失掉，而有一部分前冲动能会转化为旋转动能而增强了球体旋转。但是这时候压不住球旋转的原因主要还是由于球体前冲动能的损失造成击球合力减小，按照正常速度的时候拍面倾斜到30度就可以把旋转抵消而使球上台，但是如果前冲力度没了，拍面还压到30度就借不上力，这样去碰球会下网，所以一般我们下意识都会把拍面立起来去触球，这时候就吃转。会反拉的球友应该尝试过，对于对方拉球擦网后球速变慢的半高球，如果用反带或者发力反拉的方式去击球的话，命中率反而能提高。

问：正手攻球练习要达到什么样的程度才算过关，才可以进一步进阶练习？

答：正手攻球达到什么样的熟练程度可以算过关，这是很多初学者觉得模糊的一个概念。有的人认为，可以打到几十个回合就差不多了，就可以进一步学习弧圈球了，可是在这里我要告诉你，回合数量仅仅是评判技术达标的一个附加条件，而非主要条件！

刻意以回合数量的多少来判定正手攻球是否过关，对于很多人来说容易陷入一个误区――我已经可以打到几十个回合了，应该过关了吧（实际上他自己也不清楚什么是"过关"），可以练弧圈球了吧？可是很奇怪，当他们兴致勃勃地开始练"弧圈"时，问题却又接二连三地出来了，感觉起起伏伏，反反复复，时常懊恼不已却又很不甘心。
要想衡量自己的攻球技术是否过关，我教你一个评测的方法：

1.在回合练习的时候能否放松精力，也就是说不需要100%地集中注意力才不会失误（达到几十个甚至上百个回合）？一般如果能够集中60%的注意力就可以多回合的话就算过了"固定节奏关"。

2.在回合练习的时候能否想快则快，想重则重；想慢则慢，想轻则轻？快和重一般比较容易做到（尤其是只会用手扇球的），但是真正要想慢和轻就不那么容易了，"慢"和"快"的变化体现在节奏击球点的变化上，"重"和"轻"则是力度的控制，但是这里的力度要求用全身（腰腿）来掌握，而非只用手发力和减力。假如能做到快慢自如，随心所欲，可以全身协调柔和地进行攻球练习，那你就过了"变化节奏关"和"身体控制关"。

3.在回合练习中能否去观察每一个回球的落点差距，看自己的回球会不会让对方难受（最明显的就是对方一会儿伸胳膊一会儿夹手，为了回接你落点偏差大的球），假如两个人都有这种调控意识，都会在对方回接了一个难受球后在下一球尽量去调整自己的回球节奏，尽量让对方打得舒服，那就很容易进入多回合，但若只顾自己打得痛快而不顾对方，那就会让对手很累，这样也就无法起到一个互利的练球效果。有时候总是调节不过来，那是因为回合节奏频率超出了你自身的节奏控制范围，这时候就要学会"慢"下来，把球回轻，稳定后再快。如果能够有这样的意识，并且慢慢能够发现其中的诀窍，那你就过了"微调节奏关"。

4.在上面三点都过了以后你可以尝试一下，能否在中等慢节奏回合练习的基础上一边打球一边看书（或者让别人拿一张写着一段文字的纸在你旁边），你能否在不失误的情况下把这段文字读出来。如果做到这一点，那恭喜你，基本大致过关，可以进行中台攻球练习以及弧圈球练习了（实际上不用说，你自己已经有感觉了）

问：如何才能练好弧圈球？

答：弧圈球技术作为当今乒坛的主流，不少球友在练球时都跃跃一试，可大多数都是要么拉不好，要么只能拉一板，一旦对方把球挡回来就没有连续，自己都乱了方寸，苦恼之余总是找不到正确的方法。

其实弧圈球技术作为一项高级技术，它也是从一个基本技术上衍生出来的，这个基本技术就是正手近台快攻。正手近台攻球看似很简单，但能真正体会到其本质的球友并不多，地基越深，楼层越高，这个道理表面上谁都懂，但看看球馆里打球的球友，又有几个踏踏实实地在琢磨这个"简单"的技术呢？

问：我（或者我的小孩）想学乒乓球，是打直拍好还是横拍好？

答：以前很多人都问这个问题："是直拍厉害还是横拍厉害"，其实我们说直拍和横拍打法各有各的特点和优势所在，直拍的优势在于台内球控制灵活，变化多，而横拍则打相持的稳定型比较好，护台面积比较宽。

成年人学球的话完全可以根据自己以前的喜好选择横拍或直拍；而少儿刚开始学球，一般我们都推荐大多数小孩儿学习横拍，因为相对来说，少儿学习横拍上手快，比较容易，而能练得好直拍的小孩必须有很高的天赋，直拍的难度就在于反手违背人体正常的生理结构，无论是推挡还是直拍横打都是易学难精的。

问：小孩要学乒乓球是跟大班上课好还是单独找教练一对一来教好？

答：小孩要学乒乓球，最重要的就是培养孩子的兴趣，如果没有兴趣，靠强制性让孩子学球是肯定学不好的。那么怎么能够培养孩子对乒乓球的兴趣呢？

当然，如果在一个大班环境里，学球的孩子很多，那么互相之间打球比赛就会很有意思，这样孩子的兴趣也会比较浓厚，而且还能有一定的竞争意识。但是大班带课，教练毕竟精力是有限的，正所谓一壶水灌不满若干杯，那么这时候教练的精力只会集中在那些悟性教高，自觉性较高的小孩身上，其余的也只能随便糊弄一下了。那么这样对于其他孩子来说，能学到的东西可谓少之又少。而且大班里的孩子之间互相练球，一般来说失误都会比较高，这样对于培养扎实基本功底是很不利的。这时候如果想要快速提高小孩的水平，就需要找教练"开小灶"，进行一对一的基本功训练。

对小孩进行一对一的训练通常会比较枯燥，可能开始小孩还会有些兴趣，但是时间长了以后小孩都会产生厌烦感，会有一定的抵制情绪，自觉性差的比如练球偷懒不认真，精力只能集中20分钟左右等，这时候就需要教练用一定的方法来克服这个问题，充分调动起小孩练球的积极性，否则就是浪费时间了。

我建议，如果要让小孩子学习乒乓球，刚开始先找教练一对一进行教学，待小孩练出一定的基本功，有一些比赛能力之后，可以让孩子参加一个大班，在这种氛围中增强其兴趣，并且同时再进行着一对一的训练，这样的效果肯定要比只选择大班或者单陪好得多。

问：别人常说某某人手感特别好。什么叫手感？怎么样练习能提高？

答：手感，从字面意义上来理解，就是指打球时手上感觉的细腻程度。具体来说，主要指的是击球时的力度控制感觉，以及切球摩擦的厚薄及角度。不同的人天生的手感细腻程度不一样，有的人手感细，而有的人感觉粗，不过通过一定的练习方法每个人的手感都能够有不同程度的提高。

那么手感怎么练习呢？当然，如果多打练习比赛，通过观察别人怎么去控制，然后自己模仿尝试，这样能够提高自己的手感控制能力；但是如果没有时间经常去打球怎么办呢？有三种简单的方法可供大家平时练习。

一、对墙托球练习
距离由近到远，然后由远到近，不落地托球，反复练习，直到能够做到很随意也能控制得住（很随意指的是注意力不用像刚开始练习的时候那么使劲集中才盯得住球，有时候偶尔瞟一眼别的地方球也不会丢），像有的小孩开始这么练习的时候可以落地一点，跳起来以后再对着墙上打。
二、对球摩擦与反摩擦练习
先用合力发球的方式摩擦球的下部，使其产生强烈旋转，并且基本垂直向上弹起，待球落下来时拍面倾斜去接触旋转强的球，再使其垂直向上弹起。反复练习找摩擦与反摩擦的感觉。
三、缓冲接球练习
把球向上抛起，然后在球下落的时候用拍子通过缓冲的方法接住球，使球直接停在拍子上而不会弹起来。

以上三种方法只要经常练习，一定时间之后打球的手感必然会有提高的，当然提高速度的快慢视各人悟性的高低而各有不同。

乒乓球几种主要接发球的方法

2012-03-05T21:10:00.001-08:00

几种主要接发球的方法

一、接急球
　　
　　所谓急球是指对方发出的直线、斜线或中路底线的长球，具有角度大、速度快的特点。
　　回接急球时，站位应偏远一点，以便做好充分的准备，判断和起动都要快。根据来球的速度、旋转和落点，采取点、拉、冲、拨、推等方法来回接。接正手位的奔球、侧旋球或侧上旋球，都以点、攻、冲为主；接侧旋急长球，以拉冲为主；接反手位的奔球、侧旋或侧上旋球时，多以快推、快拨对方大角度或用反手攻和侧身点、冲方法。
　　
　　二、接下旋球
　　
　　接下旋球可用稳搓、摆短、劈长、挑、拉冲等方法
　　对于初学者，回接下旋球的最基本方法就是稳搓，要求搓稳、搓低、不能下往。
　　对具备一定水平的乒乓球运动员，接下旋球时，一定要积极主动，要加大回接难度质量。如对方发球旋转很强，就要用摆短、劈长方法回接，还要加大回接的旋转和落点难度。
　　由于下旋球具有速度不是太快而旋转变化较大的特点，因此，接发球的准备时间较充足，而在判断旋转强度和回接球的手上控制难度要加大。
　　强烈下旋球一般都用手法相似的不转发球相配套。这就要求接发球者判断要准确，看清来球旋转强度和落点后，敢于上手。如果没有胆量，求稳搓接，甚至托球，多半会被对方抢攻。
　　搓接不转球，不会使球产生较大的旋转变化，容易被对方抢攻，造成被动或失分。
　　在运用反手拉球技术回接反手位侧下旋长球时应注意：如对方发球的速度不是太快、角度不大、旋转一般时还比较容易回接。但如果对方发球质量较高，就要求两面拉球或冲球时手感要强，用摩擦旋转来克制对方的旋转。让位要充分，抢冲对方两大角。如能对来球判断准确，用搓挤的方法回接也很有效。如对方的发球是急下旋，用正常的搓球方法回接容易出高球，用推、拨的方法回接又容易下网。这时可用搓挤回接，还可使回球产生一定的急下旋，但要注意掌握好击球时间、拍形及用力方法。

三、接左、右侧上、下旋球
　　
　　站在反手位侧身用正手发球，可使球产生左侧上、下旋。站在反手侧身位，用反手发球，使球产生右侧上、下旋。无论是高抛还是低抛、反手还是正手发球，除下旋球和不转球外，基本上都是左、右侧上、下旋球。但左、右侧上、下旋球是一个统称，也只是一个旋转的概念，并不包括速度和落点的因素。左、右侧上、下旋球都有斜线长、短球，中路长短球，直线长、短球之分。
　　在这其中还有以旋转落点为主或以速度落点为主之分。同样是左侧下旋斜线长球，一个是斜线角度大，旋转较强；另一个则可能斜线角度大、速度快。
　　因此说，左、右侧上、下旋球是一个统称。如果详细用旋转、速度及落点划分起来，可分出几十种。
　　对发球者来讲，较大的发球旋转变化，都是在球拍触球的一瞬间，通过调整拍形和触球用力方向而产生的。这就要求接发球者在判断准确的基础上采用相对固定的接发球模式，并在这一接发球模式的制约下，加强有针对性的强化训练，以提高接发球的质量和命中率。
　　接出台长球或半出台球，无论是直、中、斜线侧上、下旋或半出台球，一定要立足于抢拉、抢冲或抢点。至于在什么情况下运用，则要根据对方发球的速度、旋转及落点而定。接旋转较强的侧下旋长球或半出台球，以抢拉高吊弧圈为主。
　　四、接短球
　　
　　短球也是一个统称，从路线上可分为反手位、中路、正手位短球。从旋转上可分为上旋、下旋、侧旋、侧上旋、侧下旋和不转的短球。
　　在接短球的方法上，要根据不同球性而异，当然不排除同一种发球可用几种回接方法。比如：接正手位一般侧下旋的短球，可摆短、也可劈长，可快挑、也可以晃接。在这种情况下，接发球的方法就取决于你本身接发球的能力。如能熟练地运用上述各项技术，就可以速度快、积极主动的挑、撇为主，以提高接发球的质量。
　　目前，高水平的乒乓球运动员接发球的抢攻能力都很强，对出台或半出台球，无论其旋转速度如何，都能以质量较高的弧圈球进行接发球抢攻。这就迫使发球者多以短球来制约对方，而且短球发的落点严格，球的第二跳都不得从球台的边线或端线出台，同时还伴有手法极其相似的旋转反差变化。因此，要求回接短球时首先是头脑冷静，判断准确；然后是接球的手法合理，快挑、摆短、劈长等方法要合理运用。要根据来球的性质及本人的技术水平、打法特点来选择回接方法。
　　值得注意的是，受固有的方法意识影响或恐惧对方弧圈球的心里作用，有些选手的回接短球以摆短多、而劈长、撇长少，显得接发球过于保守且威胁性差。应当讲，快速加转摆短球对制约对手抢攻是一个行之有效的方法，但一味的摆短，使回接球的落点、线路变化不多，也会削弱摆短威胁。
　　发长球要有不怕对手拉的准备，主动打实力。劈长球也一样，迫使对方大幅度移动和让位，抢拉弧圈，然后，你有充分的时间准备和落点制约，准备带、打弧圈，进行实力之争。如果摆短出半高球，易被动挨打，球靠近球网，易被对方抢攻。
　　因此，接对方反差较大的短球进行摆短，要求回球快、短、低、转，缺一不可。
　　劈长球，多半在正手空位或反手追身，回球角度大、线路长，容易在下一板球转为相持。因此，回接短球时，一定要提倡积极主动，多以挑、点、撇为主。然后，是根据来球摆短、劈长灵活运用，不拘一格。回接的方法多、落点活。
　　当然，接发球的方法不排除战术的需要，而且服从战术的需要还是第一位的。
　　比如：对方发球抢攻是特长，是主要得分手段，尤其是擅长正手位和中路抢拉弧圈球。那么，就要求接发球的第一板，**对方反手大角度，使其很难侧身抢拉，只好再过渡一板。这样从整体战术的角度要求，就有效的破坏了发球者的抢攻。在回接球的方法上，要求落点严格是非常重要的。
　　
　　对发球的准确判断，是接好发球的基础和前提，也是处理好前三板球的首要环节。以下，从六个方面对发球的判断进行解析。
　　一、发球种类的判断
　　首先，判断发的是左边球、右边球还是中间球。其次，判断球发的是长球还是短球。再次，判断发球的旋转和强度。根据发球的方向、长短和旋转强度，及时调整好站位和确定接球的方法。
　　
　　二、运行方向的判断
　　判断发的是左边球、右边球还是中间球，这主要看触球的用力方向以及球拍的运行轨迹，向左，发的就是左边球，向右，发的就是右边球，居中的是中间球。
　　
　　三、长短位置的判断
　　判断球发的是长球还是短球，这要看对方发球的第一落点离网的远近。离网近的，过来的是短球；离网远的，就是第一落点在发球端线附近的，过来的是长球。
　　
　　四、旋转类别的判断
　　发球旋转类别大体上分为八种：上旋、下旋、左侧旋、右侧旋、左侧上旋、右侧上旋、左侧下旋、右侧下旋。虽然这八种发球说起来很简单，但准确判断识别，却又很困难。这是因为球拍的覆盖物的不同、力量的大小、出手的快慢、击球位置的区别、击球时机的变换、以及假动作的欺骗等等！都是造成对发球判断难度的基本因素。
　　
　　五、旋转强度的判断
　　要判断出球的八种旋转,业余选手经过努力是可以做到的,但要识别出旋转的强度确实相当困难,咱们不说业余的,就是专业的甚至是世界超一流选手,也经常在这一难点上出错。所以我说：咱们这些业余的能知道是啥转就不错了！！但既然提到了这个问题，我就给球友说上几句，凡是发球好的选手，四个部位（腰、臂、腕、指）的运用都比较合理，是一种合力，特别是手腕抖动的又快又狠，所以发出的球特别转。张晓鹏博士的物理测试：反胶能达到107转、正胶能达到97转。那么乒乓球选手发出的球，我看也只能达到70、80转就不错了！一般称在10转以下是不转球，10转以上又分为弱下和强下旋两种。
　　
　　六、真假动作的判断
　　目前而言，欧洲选手的发球普遍比亚洲选手要强，就逆向旋转发球是欧洲选手发明的，而且在实战中运用自如，威胁很大！还有欧洲选手是用大力发球，而中国用得是中力，所以发出的球就没有人家的转。特别是以瓦尔德内尔为代表的一批选手，从遮挡到晃动发球，也就是真假动作的转换到欺骗，更是表演的淋漓尽致！就发球的假动作而言，是指触球的前后，主要分为前期假、后期假和前后假三种，以达到以假乱真，真假难辩。再加上出手抖动的快，常常假的就误认为是"真"的了！这也灵验了一句话:"在这个世界上只有"假"的才是最真的"！
　　
　　技巧：
　　⒈ 注意发球动作要符合规则：
　　发球动作只有两部分组成，⑴一只手的上抛动作：上抛高度大于等于16cm，上抛动作要在球台端线外、高于台面且需垂直上抛；⑵另一只手的挥拍动作：若按照新规则，要高于台面，并且要使两侧居中的裁判和对方运动员的视线，能看清动作。
　　
　　⒉ 注意发球的针对性：
　　知已知彼，百战百胜。发球前，应尽可能地了解对方的基本情况和特点：基本情况主要有 ⑴是直拍还是横拍；⑵是左手还是右手；⑶ 是亚洲选手还是欧美选手；⑷是生胶还是半长胶；⑸是反胶还是正胶；⑹是近台快攻打法还是削攻打法；⑦是初次见面还是熟手。对上述情况，要做到心中有数。如果有条件的话，最好通过热身、录像、报导等，了解对方的特长，了解对方发球、击球、落点规律和球路。
　　
　　⒊ 注意发球直接得分：
　　通过学习研究各种螺旋发球，练就最拿手的发球和绝招发球，如练发擦边球、回头球、近网边线球，在发球的开局，直接得分。在开局和中局，就争取主动，把比分拉开，这在"＋一分制" 中，显深得格外重要；
　　
　　⒋ 注意为发球抢攻做准备：
　　总体上来说，发球为抢攻做准备的宗旨：就是用各种方法提高发球的质量，增加对方接球的难度，使对方回球质量不高，从而为抢攻创造了条件。
　　
　　具体说来，应注意下面几点：
　　⑴利用对方的漏洞、和弱点，在落点、旋转、力量、曲线上不断地变化，从而提高发球的质量，创造抢攻的机会；
　　⑵研究发球的规律，在发球时，就大体上可以预测对方回球的线路，从而提高抢攻成功的概率。
　　⑶利用组合发球的威力，调动对方。如发近网、短而转的球，组合发底线，左、右、近身、长而急的球，往往能收到事半功倍的效果；
　　⑷利用旋转的组合，如发近网转和不转的球，及发近网侧下旋球和"左爆冲侧上螺旋球" ，把球发到对方左边线。这样旋转的组合，使对方感到难于适应，从而控制了比赛的节奏，使攻球频频得分。
　　
　　⒌ 注意发球的力量：
　　谈到发球的力量，特别是发球加力，人们常会联想到加力的后果：不是球飞出界，就是球弹跳太高。但是实际上，发加力短球，球又短、又转、又低、落点好；发加力长球，球又长、又急、又转、落在左右边角上，正是体现了乒乓球的艺术性、和技术性。它不仅在实践中可以做得到，在理论上也是正确的。只要我们在加力时，控制好撞击力和磨擦力的比例，适当增加球在球拍上磨擦时的螺旋线的长度、减少磨擦厚度、适当延长球在球拍上磨擦的时间，就可以达到上述效果。

⒍ 注意发球的旋转：
　　乒乓球旋转的多样性和由此产生的曲线的丰富性，在所有的球类运动中是独一无二的。那么如何制造出各种各样的旋转，特别是动作相似而性质不同的旋转呢？主要应注意如下几条：
　　⑴用球拍不同部位击球和磨擦球，发出不同旋转的球。如用拍面下侧与拍面上侧击球和磨擦球，就可以发出相应时的转与不转球；
　　⑵用螺旋线引拍，如果在不同阶段和不同方向击球和磨擦球，会产生不同旋转。下螺旋线方向触球会产生下螺旋；上螺旋线方向触球会产生上螺旋；
　　⑶用手腕发力方式不同，产生不同的旋转：如果是弹击发力，则不太转，如果是上螺旋线形摩擦发力，则是上螺旋式旋转；
　　⑷适当增加海绵厚度，增强球拍粘性，可以增强乒乓球的旋转。特别是在使用大球以后，这个问题显得更加重要；
　　⑸增加合力作用在球拍上的时间和距离：如在发加转螺旋球时：应用靠近拍面右侧的部位摩擦球；如在发不转螺旋球时：应用靠近拍面左侧的部位摩擦球；
　　⑹ 动作适当加大，加快摆速，并切得薄：这样在摆速方向远离球心的条件下，摆速越快，击球力量就越大，球拍摩擦球的力量也就加大了，因此球的旋转就得到加强；
　　
　　⒎ 注意发球的变化：
　　发球变化莫测，常使对方不知所措。但是我们常会看到：在比赛中，包括一些大赛中，有些运动员，从头到尾，只用一种或二种发球。发球单调，落点也单调，常使对方较快就适应，而处于被动挨打的境地。因此多准备几套发球，如正手、反手、侧身发球、上螺旋、下螺旋、长螺旋、短螺旋等等，充分发挥发球阶段主动时机，努力做到：六结合＋组合，并在发球时就准备好几套发球抢攻的路线，常会使我们处于不败之地！
　　
　　⒏ 注意发球的创新：
　　不断提高发球质量，不断创造新的发球，是乒乓球运动发展的需要，也是乒乓球运动富有生命活力的体现。在一种高质量新的发球面前，由于对方对它陌生，头脑中尚未建立条件反射。因此在击球时，感到不协调、不顺手，甚至束手无策，这样就导致发球直接得分，或间接得分，这就充分显示了新发球的巨大威力。最近，笔者研究发一种"左爆冲侧上螺旋球" ，把球加力、加速、加螺旋，从本方左中端线，发到对方左边线，在对付横拍，特别是对付直拍和直拍长胶及削球手，收到很好的效果。

乒乓球横板发球的技巧与应用

2012-03-05T12:06:00.001-08:00

这是一个业余球手的总结，有些道理。

许多朋友在打球时都会感叹，假如我有一个好的发球，就好了。因为往往在一场比赛中，你总是感觉到，对对方的发球有些不知所措。也正式因为如此，很多人利用自己独特的发球赢得了一场又一场比赛。可见，一个好的发球是多么的重要--好的发球是成功的一半。
　　下面以我的个人经验为例，向大家具体讲述一下我的发球：
　　我的发球多以正手居多，反手只是作为一种调节的手段。（在比赛过程当中，当你的正手发球被对手适应的情况下，换一换另外一种发球方式作为调节，是比较有效的）
　　站立姿势（即发球的预备姿势）（我所讲的所有动作均以球案的底线为基准）左脚在前，右脚在后（我是右手横握球拍）身体稍稍右转，这样有利于在以后的发球当中很好的运用腰部力量。左手将球置于掌心，右手手腕稍微回收，有利于手腕的发力，一切准备停当，下面就是发球的重头戏了，你的发球质量如何，就看以下的环节了。
　　一、身体重心下沉，两膝关节稍微弯曲，便于发出各种不同的旋转的球。左肩稍比右肩靠后，目的是便于从前向后收身体，在向前发力。身体稍稍有点弓。也是同样的道理。
　　二、将球向上抛起，同时整个身体舒展开，持拍手从身后由上至下用力挥下。
　　三、在球拍触及球的同时，可以发出各种不同旋转的球，也可以发出不同速度的球。（这是我发球的奥秘之所在）
　　我的发球的动作有时很大，有时很小，也是为了迷惑对方，因为在很多情况下，有很多的业余选手，是看你的动作，而不是同过你的来球方向和来球速度，所以这正好给了你一个可以利用的机会。
　　在球拍触及到球的同时，同样的一个动作可以发出不同的球，这是各位都知道的，但是当你在发球的时候，你的球的出去的时间差将是你制胜的关键。有时早，有是晚，对方将很难从你的动作中看出你是什么时候发的球。
　　发下旋球，你可以在球落到你的胸前的位置时，用球拍的正面去摩擦球的正底部，这是发出的球的旋转最强，但是对方却通过你的动作和你的出球时间，认为你所发的是不转的或是"上旋"――这是我惯用的招式。
　　发上旋球，你在球下落到快接近案子的时候，用拍子的上方去摩擦球的后上部（以球拍面与地面垂直为基准）这时的动作看上去象下旋球，但是它所发出的是上旋球，而且是旋转比较强的上旋，对手即便是对此球有所判断，也不会很果断的回击，因为他不会认为是上旋。这是我得分的重要手段。
　　发奔球--你用球拍的背面正对对方，在球下落时，利用球拍的粘性和球的下落速度。将球击出，击出的球速开始不是很快，但是在接触到对方的案子时，会突然的向上拱，所以很多人对付此球总是感到措手不及，但是此球不能一直使用，因为比较明显。与此球同样的动作还有一种下旋球，也是这样的动作，但是在击球的时候，拍子稍微向下磕一下，速度一样，却可以发出下旋球，在对手吃了第一个奔球后，紧跟着使用，比较有效。

MAC address lookup using Java

2012-03-05T11:58:00.001-08:00

MAC address lookup using Java

Posted 2007-07-09 in Java.

Code to extract the MAC address of the network card has been in UUID for a long time now. Because some people download UUID for just the MAC address part, here is a short explanation of how that code works and how you can use it in your projects.

First, download UUID and open com.eaio.uuid.UUIDGen. The MAC address extraction is performed in the static initializer.

The code does a little bit of OS sniffing to find a suitable program which is then used to print the MAC address. The output of this program is read in and parsed.
Operating systems
HP-UX

On HP-UX, /usr/sbin/lanscan is started.
Linux/MacOSX/possibly other Unices

The /sbin/ifconfig command is used.
Windows

ipconfig /all is used.
Solaris

On Solaris, the first line of the host name list is used to call /usr/sbin/arp. The code is somewhat equivalent to /usr/sbin/arp `uname -n | head -1`.
Ripping the MAC code

    * Download the latest version of the UUID software and extract the archive.
    * Copy the following source files from the uuid-x.x.x/src/java folder into your project:
          o com/eaio/util/lang/Hex.java
          o com/eaio/uuid/MACAddressParser.java
          o com/eaio/uuid/UUIDGen.java
    * Copy the static initializer up to and including

      if (macAddress != null) {
          if (macAddress.indexOf(':') != -1) {
              clockSeqAndNode |= Hex.parseLong(macAddress);
          }
          else if (macAddress.startsWith("0x")) {
              clockSeqAndNode |= Hex.parseLong(macAddress.substring(2));
          }
      }

into a new class.
* Retrieve the MAC address as clockSeqAndNode variable.

That's all.

这几个常见俚语的变迁,还真不知道

2012-03-05T11:37:00.001-08:00

1，"嫁鸡随鸡，嫁狗随狗"，原为"嫁乞随乞，嫁叟随叟"意思是一个女人即使嫁给乞丐或者是年龄大的人也要随其生活一辈子。随着时代的变迁，这一俗语转音成鸡成狗了。
　　2，"三个臭皮匠，顶个诸葛亮"，"皮匠"实际上是"裨将"的谐音，"裨将"在古代是指"副将"，原意是指三个副将的智慧合起来能顶一个诸葛亮。流传中，人们将"裨将"说成了"皮匠"。
　　3，"不见棺材不落泪"，本是"不见亲棺不落泪"，并不是见了任何棺材都落泪。讹变为"不见棺材不落泪"，如果不管谁的棺材，只要见到就落泪，那就有点太莫名其妙了。
　　4，"有眼不识金镶玉"，本是"有眼不识荆山玉"。荆，指古代楚国；"荆山玉"，是玉匠在荆山发现的玉。
　　5，"不到黄河心不死"，本是"不到乌江心不死"。乌江，项羽他老人家自刎的地方。乌江讹变成黄河，真是让人无从解释了。
　　6，"舍不得孩子套不住狼"本是"舍不得鞋子套不住狼"意思是要打到狼，就要不怕跑路，不怕费鞋。不过这个我还能理解点，因为好像四川那边管鞋叫孩子。如果真的拿生的孩子去套狼，也太恐怖啦！
　　7，"狗屁不通"，这个成语最初是"狗皮不通"。狗的表皮没有汗腺，酷夏，狗要借助舌头来散发体内的燥热。"狗皮不通"就是指狗的身体这个特点，"屁"是污浊都象征，对于文理不通的东西，以屁来喻，也就将就吧！
　　8，"王八蛋"这是民间的一句骂人话。实际上，这句话的原来面目是"忘八端"。古代是，"八端"指"孝，悌，忠，信，礼，义，廉，耻"，此八端指的是做人之根本，忘记了这"八端"也就是忘了基本的做人根本，可是后来却被讹变成"王八蛋"。

Oracle在Windows下的操作系统认证总结

2012-03-05T02:24:00.002-08:00

一、普通用户

1. 在 windows 下创建用户 niu，或将域用户加入本地组。

2. 修改参数文件 os_authent_prefix 默认值“ops$”。

3. 修改注册表，oracle/home0 下添加 OSAUTH_PREFIX_DOMAIN 项，如果使用域，设为 true，否则设为 false；如果不是在域中，并且将其设为 true，域用机器名代替，如果不添加该项，默认值为 true。

4. 修改 SQLNET.ORA 中的 SQLNET.AUTHENTICATION_SERVICES = (NTS) 或将其注释掉，不能设为 NONE。（该项说明使用操作系统认证）

5. 连接到 Oracle，创建相应的用户：

OSAUTH_PREFIX_DOMAIN 为 TRUE 时：

Create User “OPS$DOMAIN_NAME\NIU” IDENTIFIED EXTERNALLY;
注：在使用 DOMAIN_NAME\ 时，因为有特殊符号 \，所以要用双引号包起来，此时双引号中所有字符必须用大写。

OSAUTH_PREFIX_DOMAIN为 FALSE 时：
Create User OPS$niu IDENTIFIED EXTERNALLY;
赋予给用户一些权限，如：
SQL>GRANT CONNECT TO "OPS$DOMAIN_NAME\NIU"（OPS$niu）;
Grant succeeded.
SQL>
6. 以 NIU 用户登录操作操作系统
SQL> connect /
connected
SQL> show user;
USER is "<OPS$><DOMAIN_NAME>\niu"
SQL>
7. 通常情况下，数据库用户登录后，即使没有 ALTER USER 的权限，也是可以修改自己密码的，但若是以此认证方式登录数据库，则不可以（未经确认，只是尝试失败得到的结论，但仔细想想，这样要求也合理）

二、超级管理员用户

1. 与普通用户差不多，需要在创建 windows 中创建组 ora_dba（默认情况安装 oracle 的时候已经建立，ORA_<sid>_DBA 只对指明的 sid 有超级管理员权限），并将本地用户或域用户加入该组。（无需再创建 oracle 用户，相当于用 sys 登陆，os_authent_prefix 也就不起作用。）

2. 用该用户登陆 windows
连接 oracle ：

SQL> connect / as sysdba
connected
SQL> show user;
USER is "sys"
SQL>

三、几个参数说明

1. 初始化文件中的 os_authent_prefix：指明 Oracle 帐户对应 OS 帐户的前缀。

2. 注册表中的 OSAUTH_PREFIX_DOMAIN ：如果不指明域（或机器名），一定要将其设为 false，通常这是造成认证失败的原因。

3. sqlnet.ora 中 sqlnet.authentication_services=(nts) 否则产生 ora-01004 错误。

4. 初始化文件中 remote_os_authent=true ：该参数不一定要设，除非要用到客户端的操作系统认证（没有试验）。

5. 初始化文件中 REMOTE_LOGIN_PASSWORD ：只是用于超级管理员用户，设为 NONE 则只使用操作系统认证，EXCLUSIVE 可用非共享的密码文件认证，SHARED 可用共享的密码文件认证（但只能有 sys 用户为超级管理员）。注：操作系统认证优先于密码文件认证。

四、参考：

http://www.itpub.net/showthread.php?s=&threadid=207909
http://www.itpub.net/162971,1.html
http://www.cnoug.org/viewthread.php?tid=15082
http://www.cnoug.org/viewthread.php?tid=27294&sid=DU7tZYea
http://www.cnblogs.com/zyk/archive/2004/11/09/61786.aspx

Oracle merge usage

2012-03-05T02:22:00.003-08:00

CREATE OR REPLACE PACKAGE etl AS

c_inserting CONSTANT PLS_INTEGER := 0;
c_updating CONSTANT PLS_INTEGER := 1;

FUNCTION merge_counter (
action_in IN PLS_INTEGER DEFAULT c_inserting
) RETURN PLS_INTEGER;

FUNCTION get_merge_update_count RETURN PLS_INTEGER;

FUNCTION get_merge_update_count (
merge_count_in IN PLS_INTEGER
) RETURN PLS_INTEGER;

FUNCTION get_merge_insert_count RETURN PLS_INTEGER;

FUNCTION get_merge_insert_count (
merge_count_in in PLS_INTEGER
) RETURN PLS_INTEGER;

PROCEDURE reset_counters;

END etl;
/

CREATE OR REPLACE PACKAGE BODY etl AS

g_update_counter PLS_INTEGER NOT NULL := 0;
g_insert_counter PLS_INTEGER NOT NULL := 0;

/*-------------- START OF FUNCTION merge_counter --------------------*/
FUNCTION merge_counter (
action_in IN PLS_INTEGER DEFAULT c_inserting
) RETURN PLS_INTEGER IS
BEGIN
CASE action_in
WHEN c_updating
THEN g_update_counter := g_update_counter + 1;
WHEN c_inserting
THEN g_insert_counter := g_insert_counter + 1;
ELSE
RAISE PROGRAM_ERROR;
END CASE;
RETURN 0;
END merge_counter;

/*----------- START OF FUNCTION get_merge_update_count V1 ---------------*/
FUNCTION get_merge_update_count
RETURN PLS_INTEGER is
BEGIN
RETURN g_update_counter;
END get_merge_update_count;

/*----------- START OF FUNCTION get_merge_update_count V2 ---------------*/
FUNCTION get_merge_update_count (
merge_count_in IN PLS_INTEGER
) RETURN PLS_INTEGER IS
BEGIN
RETURN NVL( merge_count_in - g_insert_counter, 0 );
END get_merge_update_count;

/*----------- START OF FUNCTION get_merge_insert_count V1 ---------------*/
FUNCTION get_merge_insert_count
RETURN PLS_INTEGER IS
BEGIN
RETURN g_insert_counter;
END get_merge_insert_count;

/*----------- START OF FUNCTION get_merge_insert_count V2 ---------------*/
FUNCTION get_merge_insert_count (
merge_count_in IN PLS_INTEGER
) RETURN PLS_INTEGER IS
BEGIN
RETURN NVL( merge_count_in - g_update_counter, 0 );
END get_merge_insert_count;

/*-------------- START OF FUNCTION reset_counters --------------------*/
PROCEDURE reset_counters IS
BEGIN
g_update_counter := 0;
g_insert_counter := 0;
END reset_counters;

END etl;
/

2. 创建一个验证的sql文件：run_mrg.sql
SQL code
set serverout on
set echo on
set pagesize 100
--
-- Run merge...
--
begin

etl.reset_counters;

merge into target tgt
using source src
on (src.id = tgt.id)
when matched then
update
set value = (case etl.merge_counter(etl.c_updating)
when 0
then src.value
end)
when not matched then
insert
( tgt.id
, tgt.value )
values
( case etl.merge_counter(etl.c_inserting)
when 0
then src.id
end
, src.value );

/* Use update count... */
dbms_output.put_line(sql%rowcount || ' rows merged.');
dbms_output.put_line(etl.get_merge_update_count || ' rows updated.');
dbms_output.put_line(etl.get_merge_insert_count(sql%rowcount) || ' rows inserted.');

/* Use insert count... */
dbms_output.put_line(etl.get_merge_update_count(sql%rowcount) || ' rows updated.');
dbms_output.put_line(etl.get_merge_insert_count || ' rows inserted.');

end;
/

3. 验证上述用法：
create table source ( id int, value varchar2(1) );
create table target ( id int, value varchar2(1) );

insert into source select rownum, substr(object_type,1,1) from user_objects where rownum <= 15;
insert into target select * from source where rownum <= 10;
commit;

运行结果如下：
SQL> insert into source select rownum, substr(object_type,1,1) from user_objects where rownum <= 15;

已创建11行。

SQL> insert into target select * from source where rownum <= 10;

已创建10行。

SQL> commit;

提交完成。
SQL> @E:\MyDocument\notes\oracle_run_merge.sql
SQL> set serverout on
SQL> set echo on
SQL> set pagesize 100
SQL> --
SQL> -- Run merge...
SQL> --
SQL> begin
2
3 etl.reset_counters;
4
5 merge into target tgt
6 using source src
7 on (src.id = tgt.id)
8 when matched then
9 update
10 set value = (case etl.merge_counter(etl.c_updating)
11 when 0
12 then src.value
13 end)
14 when not matched then
15 insert
16 ( tgt.id
17 , tgt.value )
18 values
19 ( case etl.merge_counter(etl.c_inserting)
20 when 0
21 then src.id
22 end
23 , src.value );
24
25 /* Use update count... */
26 dbms_output.put_line(sql%rowcount || ' rows merged.');
27 dbms_output.put_line(etl.get_merge_update_count || ' rows updated.');
28 dbms_output.put_line(etl.get_merge_insert_count(sql%rowcount) || ' rows inserted.');
29
30 /* Use insert count... */
31 dbms_output.put_line(etl.get_merge_update_count(sql%rowcount) || ' rows updated.');
32 dbms_output.put_line(etl.get_merge_insert_count || ' rows inserted.');
33
34 end;
35 /
22 rows merged.
20 rows updated.
2 rows inserted.
20 rows updated.
2 rows inserted.

PL/SQL 过程已成功完成。

SQL>

上述过程我是从asktom上整理出来的。希望对你有所帮助。
merge本身是不带有updated和inserted的详细信息的。

MySQL分组排名查询

2012-03-05T02:02:00.002-08:00

--按某一字段分组取最大(小)值所在行的数据
/*
数据如下：
name val memo
a 2 a2(a的第二个值)
a 1 a1--a的第一个值
a 3 a3:a的第三个值
b 1 b1--b的第一个值
b 3 b3:b的第三个值
b 2 b2b2b2b2
b 4 b4b4
b 5 b5b5b5b5b5
*/
--创建表并插入数据：
create table tb(name varchar(10),val int,memo varchar(20))
insert into tb values('a', 2, 'a2(a的第二个值)')
insert into tb values('a', 1, 'a1--a的第一个值')
insert into tb values('a', 3, 'a3:a的第三个值')
insert into tb values('b', 1, 'b1--b的第一个值')
insert into tb values('b', 3, 'b3:b的第三个值')
insert into tb values('b', 2, 'b2b2b2b2')
insert into tb values('b', 4, 'b4b4')
insert into tb values('b', 5, 'b5b5b5b5b5')
go
--一、按name分组取val最大的值所在行的数据。
--方法1：
select a.* from tb a where val = (select max(val) from tb where name = a.name) order by a.name
--方法2：
select a.* from tb a where not exists(select 1 from tb where name = a.name and val > a.val)
--方法3：
select a.* from tb a,(select name,max(val) val from tb group by name) b where a.name = b.name and a.val = b.val order by a.name
--方法4：
select a.* from tb a inner join (select name , max(val) val from tb group by name) b on a.name = b.name and a.val = b.val order by a.name
--方法5
select a.* from tb a where 1 > (select count(*) from tb where name = a.name and val > a.val ) order by a.name
/*
name val memo
---------- ----------- --------------------
a 3 a3:a的第三个值
b 5 b5b5b5b5b5
*/
--二、按name分组取val最小的值所在行的数据。
--方法1：
select a.* from tb a where val = (select min(val) from tb where name = a.name) order by a.name
--方法2：
select a.* from tb a where not exists(select 1 from tb where name = a.name and val < a.val)
--方法3：
select a.* from tb a,(select name,min(val) val from tb group by name) b where a.name = b.name and a.val = b.val order by a.name
--方法4：
select a.* from tb a inner join (select name , min(val) val from tb group by name) b on a.name = b.name and a.val = b.val order by a.name
--方法5
select a.* from tb a where 1 > (select count(*) from tb where name = a.name and val < a.val) order by a.name
/*
name val memo
---------- ----------- --------------------
a 1 a1--a的第一个值
b 1 b1--b的第一个值
*/
--三、按name分组取第一次出现的行所在的数据。
select a.* from tb a where val = (select top 1 val from tb where name = a.name) order by a.name
/*
name val memo
---------- ----------- --------------------
a 2 a2(a的第二个值)
b 1 b1--b的第一个值
*/
--四、按name分组随机取一条数据。
select a.* from tb a where val = (select top 1 val from tb where name = a.name order by newid()) order by a.name
/*
name val memo
---------- ----------- --------------------
a 1 a1--a的第一个值
b 5 b5b5b5b5b5
*/
--五、按name分组取最小的两个(N个)val
select a.* from tb a where 2 > (select count(*) from tb where name = a.name and val < a.val ) order by a.name,a.val
select a.* from tb a where val in (select top 2 val from tb where name=a.name order by val) order by a.name,a.val
select a.* from tb a where exists (select count(*) from tb where name = a.name and val < a.val having Count(*) < 2) order by a.name
/*
name val memo
---------- ----------- --------------------
a 1 a1--a的第一个值
a 2 a2(a的第二个值)
b 1 b1--b的第一个值
b 2 b2b2b2b2
*/
--六、按name分组取最大的两个(N个)val
select a.* from tb a where 2 > (select count(*) from tb where name = a.name and val > a.val ) order by a.name,a.val
select a.* from tb a where val in (select top 2 val from tb where name=a.name order by val desc) order by a.name,a.val
select a.* from tb a where exists (select count(*) from tb where name = a.name and val > a.val having Count(*) < 2) order by a.name
/*
name val memo
---------- ----------- --------------------
a 2 a2(a的第二个值)
a 3 a3:a的第三个值
b 4 b4b4
b 5 b5b5b5b5b5
*/
--七，假如整行数据有重复，所有的列都相同。
/*
数据如下：
name val memo
a 2 a2(a的第二个值)
a 1 a1--a的第一个值
a 1 a1--a的第一个值
a 3 a3:a的第三个值
a 3 a3:a的第三个值
b 1 b1--b的第一个值
b 3 b3:b的第三个值
b 2 b2b2b2b2
b 4 b4b4
b 5 b5b5b5b5b5
*/
--在sql server 2000中只能用一个临时表来解决，生成一个自增列，先对val取最大或最小，然后再通过自增列来取数据。
--创建表并插入数据：
create table tb(name varchar(10),val int,memo varchar(20))
insert into tb values('a', 2, 'a2(a的第二个值)')
insert into tb values('a', 1, 'a1--a的第一个值')
insert into tb values('a', 1, 'a1--a的第一个值')
insert into tb values('a', 3, 'a3:a的第三个值')
insert into tb values('a', 3, 'a3:a的第三个值')
insert into tb values('b', 1, 'b1--b的第一个值')
insert into tb values('b', 3, 'b3:b的第三个值')
insert into tb values('b', 2, 'b2b2b2b2')
insert into tb values('b', 4, 'b4b4')
insert into tb values('b', 5, 'b5b5b5b5b5')
go
select * , px = identity(int,1,1) into tmp from tb
select m.name,m.val,m.memo from
(
select t.* from tmp t where val = (select min(val) from tmp where name = t.name)
) m where px = (select min(px) from
(
select t.* from tmp t where val = (select min(val) from tmp where name = t.name)
) n where n.name = m.name)
drop table tb,tmp
/*
name val memo
---------- ----------- --------------------
a 1 a1--a的第一个值
b 1 b1--b的第一个值
(2 行受影响)
*/
--在sql server 2005中可以使用row_number函数，不需要使用临时表。
--创建表并插入数据：
create table tb(name varchar(10),val int,memo varchar(20))
insert into tb values('a', 2, 'a2(a的第二个值)')
insert into tb values('a', 1, 'a1--a的第一个值')
insert into tb values('a', 1, 'a1--a的第一个值')
insert into tb values('a', 3, 'a3:a的第三个值')
insert into tb values('a', 3, 'a3:a的第三个值')
insert into tb values('b', 1, 'b1--b的第一个值')
insert into tb values('b', 3, 'b3:b的第三个值')
insert into tb values('b', 2, 'b2b2b2b2')
insert into tb values('b', 4, 'b4b4')
insert into tb values('b', 5, 'b5b5b5b5b5')
go
select m.name,m.val,m.memo from
(
select * , px = row_number() over(order by name , val) from tb
) m where px = (select min(px) from
(
select * , px = row_number() over(order by name , val) from tb
) n where n.name = m.name)
drop table tb
/*
name val memo
---------- ----------- --------------------
a 1 a1--a的第一个值
b 1 b1--b的第一个值
(2 行受影响)
*/

Mysql Install by compiling the source code

2012-03-05T01:59:00.002-08:00

tar zxvf mysql-5.1.45.tar.gz
cd mysql-5.1.45
./configure --prefix=/var/lib/mysql --without-debug --with-charset=utf8 --with-extra-charsets=all --with-plugins=all
make
make install
cp support-files/my-medium.cnf /etc/my.cnf
cd /var/lib/mysql/bin
./mysql_install_db --user=mysql
chown -R root .
cd ..
chown -R mysql /var/
chgrp -R mysql .
cd ../mysql/bin/
./mysqld_safe --user=mysql & ----查看err.log
cd /var/lib/mysql/share/mysql/
cp mysql.server /etc/init.d/mysql
./mysql.server start
./mysqld_safe --defaults-file =/etc/my.cnf
/etc/init.d/mysql restart
cd /var/lib/mysql/bin/
cp mysql /usr/bin/

2.8.1. 源码安装概述
你必须执行的安装MySQL源码分发版的基本命令是：

shell> groupadd mysql
shell> useradd -g mysql mysql
shell> gunzip < mysql-VERSION.tar.gz | tar -xvf -
shell> cd mysql-VERSION
shell> ./configure --prefix=/usr/local/mysql
shell> make
shell> make install
shell> cp support-files/my-medium.cnf /etc/my.cnf
shell> cd /usr/local/mysql
shell> bin/mysql_install_db --user=mysql
shell> chown -R root .
shell> chown -R mysql var
shell> chgrp -R mysql .
shell> bin/mysqld_safe --user=mysql &
如果从一个源码RPM开始，那么执行如下命令：

shell> rpmbuild --rebuild --clean MySQL-VERSION.src.rpm
这样你制作一个可以安装的二进制RPM。

Oracle Ref Cursor 示例

2012-03-05T01:58:00.003-08:00

--如这个存储过程，该如何接收外部的一个变量进来？
create or replace procedure pro_show_emp(
empno_in in scott.emp.empno%type,--在要传进来的参数后面加上一个关键字in
cv_emp in out sys_refcursor
)
is
begin
open cv_emp for
select * from scott.emp emp
where emp.empno=empno_in;

exception
when others then
dbms_output.put_line(sqlerrm);
end pro_show_emp;
/
SQL> variable x refcursor;--refcursor:sqlplus下运行
SQL> exec pro_show_emp(7788,:x);
PL/SQL procedure successfully completed.
SQL> print x;

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO
---------- ---------- --------- ---------- -------------- ---------- ---------- ----------
7788 SCOTT ANALYST 7566 19-4月 -87 3100 20

Oracle PL/SQL notes

2012-03-05T01:55:00.003-08:00

set linesize 512
set term off verify off feedback off pagesize 999
-- set markup html on entmap ON spool on preformat off
set heading off
spool droptable.sql on

sql*plus使用的一些技巧
发表于：2005年7月5日阅读:174次

阅读本文档之前，建议先看” http://www.cnoug.org/viewthread.php?tid=16867“一文，

Sql*plus中蕴藏着好多技巧，如果掌握这些技巧，对于在oracle数据库下进行快速开发与有效维护数据库都是有益的。
　　　　下面就接受一二，
　　　

1．使用SQL*PLUS动态生成批量脚本
将spool与select命令结合起来使用，可以生成一个脚本，脚本中包含有可以批量执行某一任务的语句。
例1：
生成一个脚本，删除SCOTT用户下的所有的表：
a. 创建gen_drop_table.sql文件，包含如下语句：
SPOOL　c:\drop_table.sql
　　 SELECT 'DROP TABLE '|| table_name ||';' FROM user_tables;
　　 SPOOL OFF
b. 以SCOTT用户登录数据库
SQLPLUS > @ …..\gen_dorp_table.sql
c. 在c盘根目录下会生成文件drop_table.sql文件，包含删除所有表的语句，如下所示:
SQL>　　　SELECT 'DROP TABLE '|| table_name ||';' FROM user_tables;　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
'DROPTABLE'||TABLE_NAME||';'　　　　　　　　　　　　　
--------------------------------------------------------------------------------
DROP TABLE DEPT;　　　　　　　　　　　　　　　　　　　　
DROP TABLE EMP;　　　　　　　　　　　　　　　　　　　　
DROP TABLE PARENT;　　　　　　　　　　　　　　　　　　　
DROP TABLE STAT_VENDER_TEMP;　　　　　　　　　　
DROP TABLE TABLE_FORUM;　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
5 rows selected.　
　　　　　　　　　　　　　
SQL>　　　SPOOL OFF　
d. 对生成的drop_table.sql文件进行编辑去掉不必要的部分，只留下drop table …..语句
e. 在scott用户下运行dorp_table.sql文件，删除scott用户下所有的表。
SQLPLUS > @ c:\dorp_table.sql

在上面的操作中，在生成的脚本文件中会有多余的字符，如运行的sql语句，标题，或返回的行数，需要我们编辑该脚本后再运行，给实际的操作带来诸多不便。懒惰是人的本性，这促使我们用更简单的办法来实现上面的任务。

a. 创建gen_drop_table.sql文件，包含如下语句：
　　　　set echo off
set feedback off
set newpage none
set pagesize 5000
set linesize 500
set verify off
set pagesize 0
set term off
set trims on
set linesize 600
set heading　off
set timing off
set verify off
set numwidth 38
SPOOL　c:\drop_table.sql
　　 SELECT 'DROP TABLE '|| table_name ||';' FROM user_tables;
　　 SPOOL OFF
b. 以SCOTT用户登录数据库
SQLPLUS > @ …..\gen_dorp_table.sql
c. 在c盘根目录下会生成文件drop_table.sql文件，包含删除所有表的语句，如下所示:
DROP TABLE DEPT;　　　　　　　　　　　　　　　　　　　　
DROP TABLE EMP;　　　　　　　　　　　　　　　　　　　　
DROP TABLE PARENT;　　　　　　　　　　　　　　　　　　　
DROP TABLE STAT_VENDER_TEMP;　　　　　　　　　　
DROP TABLE TABLE_FORUM;　　　　　　　　　　　　　　　
d. 在scott用户下运行dorp_table.sql文件，删除scott用户下所有的表。
SQLPLUS > @ c:\dorp_table.sql

2．将一个表中的数据导出生成一个文本文件，列与列之间以”,”隔开
set echo off
set feedback off
set newpage none
set pagesize 5000
set linesize 500
set verify off
set pagesize 0
set term off
set trims on
set linesize 600
set heading　off
set timing off
set verify off
set numwidth 38
SPOOL　c:\drop_table.sql
　　 select DEPTNO || ',' || DNAME FROM DEPT;
　　 SPOOL OFF
将上面的内容保存为一个文本文件后，以scott登录，执行该文件后显示结果：
10,ACCOUNTING　
20,RESEARCH　
30,SALES　
40,OPERATIONS　

通过上面的两个例子，我们可以将：
set echo off
set feedback off
set newpage none
set pagesize 5000
set linesize 500
set verify off
set pagesize 0
set term off
set trims on
set linesize 600
set heading　off
set timing off
set verify off
set numwidth 38
SPOOL　c:\具体的文件名
　　你要运行的sql语句
　　 SPOOL OFF
作为一个模版，只要将必要的语句假如这个模版就可以了。

在oracle的较新版本中，还可以用set colsep命令来实现上面的功能：
SQL> set colsep ,
SQL> select * from dept;
　　　　10,ACCOUNTING　　,NEW YORK
　　　　20,RESEARCH　　　,DALLAS
　　　　30,SALES　　　　 ,CHICAGO
　　　　40,OPERATIONS　　,BOSTON
　　　　35,aa　　　　　　,bb

3．动态生成spool命令所需的文件名
在我们上面的例子中，spool命令所需要的文件名都是固定的。有时我们需要每天spool一次，并且每次spool的文件名都不相同，如文件名包含当天的日期，该如何实现呢？
column dat1 new_value filename;
select to_char(sysdate,'yyyymmddhh24mi') dat1 from dual;　
spool c:\&&filename..txt　
select * from dept;
spool off;

4．如何从脚本文件中得到WINDOWS环境变量的值：
在windos中：
spool c:\temp\%ORACLE_SID%.txt
　select * from dept;
　...
　spool off

在上面的例子中，通过%ORACLE_SID%的方式引用环境变量ORACLE_SID的值，如果ORACLE_SID的值为orcl，则生成的spool文件名为：orcl.txt

在UNIX中：
spool c:\temp\$ORACLE_SID.txt
　select * from dept;
　...
　spool off

在上面的例子中，通过$ORACLE_SID的方式引用环境变量ORACLE_SID的值，如果ORACLE_SID的值为orcl，则生成的spool文件名为：orcl.txt

5．如何指定缺省的编辑脚本的目录
　　　　在sql*plus中，可以用save命令，将上一条执行的sql语句保存到一个文件中，但是如何设置该文件的缺省目录呢？
通过SQL> set editfile c:\temp\file.sql 命令，可以设置其缺省目录为c:\tmpe，缺省文件名为file.sql。

6．如何除去表中相同的行
找到相同的行：
SELECT * FROM dept a　
WHERE ROWID <> (SELECT MAX(ROWID)
　　　　　　　　　 FROM dept b
　　　　　　　　　 WHERE a.deptno = b.deptno
　　　　　　　　　 AND a.dname = b.dname　-- Make sure all columns are compared
　　　　　　　　　 AND a.loc = b.loc);

注释：
如果只找deptno列相同的行，上面的查询可以改为：
SELECT * FROM dept a　
WHERE ROWID <> (SELECT MAX(ROWID)
　　　　　　　　　 FROM dept b
　　　　　　　　　 WHERE a.deptno = b.deptno)

删除相同的行：
DELETE FROM dept a
WHERE ROWID <> (SELECT MAX(ROWID
　　　　　　　　　　　　　　　　FROM dept b
　　　　　　　　　　　　　　　　WHERE a.deptno = b.deptno
　　　　　　　　　　　　　　　　AND a.dname = b.dname -- Make sure all columns are compared
　　　　　　　　　　　　　　　　AND a.loc = b.loc);

注意：上面并不删除列值为null的行。

7．如何向数据库中插入两个单引号(’’)
Insert inot dept values(35,’aa’’’’bb’,’a’’b’);

在插入时，用两个’表示一个’。

8．如何设置sql*plus的搜寻路径，这样在用@命令时，就不用输入文件的全路径。
设置SQLPATH环境变量。
如：
SQLPATH = C:\ORANT\DBS;C:\APPS\SCRIPTS;C:\MYSCRIPTS

9．@与@@的区别是什么？
@等于start命令，用来运行一个sql脚本文件。
@命令调用当前目录下的，或指定全路径，或可以通过SQLPATH环境变量搜寻到的脚本文件。
@@用在脚本文件中，用来指定用@@执行的文件与@@所在的文件在同一目录，而不用指定全路径，也不从SQLPATH环境变量指定的路径中寻找文件，该命令一般用在嵌套脚本文件中。

10．&与&&的区别
&用来创建一个临时变量，每当遇到这个临时变量时，都会提示你输入一个值。
&&用来创建一个持久变量，就像用用define命令或带new_vlaue字句的column命令创建的持久变量一样。当用&&命令引用这个变量时，不会每次遇到该变量就提示用户键入值，而只是在第一次遇到时提示一次。

如，将下面三行语句存为一个脚本文件，运行该脚本文件，会提示三次，让输入deptnoval的值：
select count(*) from emp where deptno = &deptnoval;
select count(*) from emp where deptno = &deptnoval;
select count(*) from emp where deptno = &deptnoval;

将下面三行语句存为一个脚本文件，运行该脚本文件，则只会提示一次，让输入deptnoval的值：
select count(*) from emp where deptno = &deptnoval;
select count(*) from emp where deptno = &deptnoval;
select count(*) from emp where deptno = &deptnoval;

11．引入copy的目的
Copy命令在两个数据库之间拷贝数据时特别有用，特别是该命令可以在两个数据库之间传递long型字段的数据。
缺点：
在两个数据库之间传递数据时，有可能丢失精度(lose precision)。

12．问什么在修改大量的行时，我的脚本会变得很慢？
当通过PL/SQL块修改一个表中的许多行时，你会创建在表上创建一个cursor，但是只有在你关闭cursor时，才会释放ROLLBACK SEGMENT，这样，当cursor仍然打开时，修改过程会变慢，这是因为数据库不得不搜寻大量的rollback segment以便于维护读一致性。为了避免这样情况，试着在表上加一个标志字段来描述该行是否已经被修改，然后关闭该cursor，然后再打开该 cursor。每次可以修改5000行.

ASA备份示例

2012-03-05T01:54:00.002-08:00

asa 备份:

映像备份：
backup database directory 'e:\\temp\\backup';

backup database directory 'e:\\temp\\backup' transaction log only transaction log rename match;

档案备份：
backup database to 'e:\temp\backup2' attended on;

MySQL ini 配置文件生成

2012-03-05T01:53:00.003-08:00

@echo off
echo "This is a demo script for auto installation of noninstall version of MySQL on Windows. "
echo "Copyright: iihero@CSDN, when you distribute it, please copy this section above the head."
echo "================================iiihero@hotmail.com====================================="
set MYSQL_HOME=%~dp0
echo MYSQL_HOME=%MYSQL_HOME%
del /F my.ini
echo [client] >> my.ini
echo port = 3306 >> my.ini
echo default_character_set=gbk >> my.ini
echo [mysqld] >> my.ini
echo default_character_set=utf8 >> my.ini
echo default_storage_engine=InnoDB >> my.ini
echo basedir=%MYSQL_HOME%>>my.ini
echo datadir=%MYSQL_HOME%data>> my.ini
echo innodb_data_file=ibdata1:50M;ibdata2:10M:autoextend >> my.ini
echo transaction-isolation=READ-COMMITTED >> my.ini
echo port=3306 >> my.ini
echo max_allowed_packet = 64M >> my.ini
echo "my.ini in %MYSQL_HOME% created."
set PATH=%MYSQL_HOME%\bin;%PATH%
if exist "%MYSQL_HOME%\bin\mysqld-nt.exe" call mysqld-nt --install-manual mysql55 --defaults-file="%MYSQL_HOME%\my.ini"
if not exist "%MYSQL_HOME%\bin\mysqld-nt.exe" call mysqld --install-manual mysql55 --defaults-file="%MYSQL_HOME%\my.ini"

Oracle connect by 示例

2012-03-05T01:52:00.004-08:00

SQL> create TABLE tb(ID char(3),PID char(3),Name varchar(10)) ;

Table created.

SQL> INSERT into tb SELECT '001',NULL ,'山东省' from dual
2 UNION ALL SELECT '002','001','烟台市' from dual
3 UNION ALL SELECT '004','002','招远市' from dual
4 UNION ALL SELECT '003','001','青岛市' from dual
5 UNION ALL SELECT '005',NULL ,'四会市' from dual
6 UNION ALL SELECT '006','005','清远市' from dual
7 UNION ALL SELECT '007','006','小分市' from dual ;

7 rows created.

SQL> select id, pid, lpad(' ', level*2, ' ') || name newname from tb start with pid is null connect
by prior id = pid;

ID PID
--- ---
NEWNAME
--------------------------------------------------------------------------------
001
山东省

002 001
烟台市

004 002
招远市

ID PID
--- ---
NEWNAME
--------------------------------------------------------------------------------
003 001
青岛市

005
四会市

006 005
清远市

ID PID
--- ---
NEWNAME
--------------------------------------------------------------------------------
007 006
小分市

7 rows selected.

SQL>

Delete Oracle用户下的表及序列(drop.sql)

2012-03-05T01:51:00.000-08:00

DECLARE
v_table_name USER_TABLES.table_name%TYPE;
v_sequence_name USER_SEQUENCES.sequence_name%TYPE;
--两个游标定义
CURSOR c_TableName IS
SELECT table_name FROM USER_TABLES;
CURSOR c_SequenceName IS
SELECT sequence_name FROM USER_SEQUENCES;
BEGIN
--打开游标
OPEN c_TableName;
LOOP
--获取表名
FETCH c_TableName INTO v_table_name;

--作删除表的操作
DROP TABLE v_table_name;
--DBMS_OUTPUT.PUT_LINE('表: ' || v_table_name);

--退出循环的条件
EXIT WHEN c_TableName%NOTFOUND;
END LOOP;

--关闭游标c_TableName
CLOSE c_TableName;

--打开序列系统游标
OPEN c_SequenceName;
LOOP
--获取序列名
FETCH c_SequenceName INTO v_sequence_name;

--
DROP SEQUENCE v_sequence_name;
--DBMS_OUTPUT.PUT_LINE('表: ' || v_sequence_name);

--
EXIT WHEN c_SequenceName%NOTFOUND;

END LOOP;
--关闭游标c_SequenceName
CLOSE c_SequenceName;
END;
/

C#捕获cmd输出示例

2012-03-05T01:49:00.000-08:00

using System;
using System.Collections.Generic;
using System.Text;

using System.Runtime.InteropServices;
using System.Diagnostics;
using System.IO;

namespace demo0
{
class main
{
static void TestImp()
{
Process sqlProcess = new Process();
sqlProcess.StartInfo.FileName = @"D:\Oracle\product\11.2.0\db1\BIN\imp.exe";
sqlProcess.StartInfo.Arguments = string.Format("{0}/{1}@{2} FILE={3} FROMUSER={4} TOUSER={5}",
"scott", "tiger", "ora102", "mock.dmp", "scott", "scott");
sqlProcess.StartInfo.CreateNoWindow = true;
sqlProcess.StartInfo.UseShellExecute = false;
sqlProcess.StartInfo.RedirectStandardOutput = true;
sqlProcess.StartInfo.RedirectStandardError = true;
sqlProcess.Start();
StreamReader sr = sqlProcess.StandardOutput;
StreamReader sr2 = sqlProcess.StandardError;

System.Console.WriteLine(sr.ReadToEnd());
System.Console.WriteLine(sr2.ReadToEnd());
}

static void Main(string[] args)
{
TestImp();
}
}
}

上例就可以把一个imp操作的结果给dump出来。

Chrome: 定制自己喜欢的Chrome

2012-03-05T01:46:00.001-08:00

Chrome确实是非常好的一款浏览器，但是也有让人不爽的地方。
那就是它默认装到C盘里，当你选择它做默认浏览器的时候，一些配置参数也丢掉了。导致cachedir等依旧在C盘里。

本文就介绍一种折中的办法，那就是将Chrome安装在默认的位置C盘，配置参数弄进注册表。
点击它，用的是新的配置参数启动。这样就不会有什么大问题了。

注册表信息变更：
Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\ChromeHTML\shell\open\command]
@="\"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe\" --disk-cache-size=41943040 --user-data-dir=\"D:\\tools\\Chrome\\Data\" -- \"%1\""

[HKEY_CLASSES_ROOT\http\shell\open\command]
@="\"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe\" --disk-cache-size=41943040 --user-data-dir=\"D:\\tools\\Chrome\\Data\" -- \"%1\""

[HKEY_CLASSES_ROOT\https\shell\open\command]
@="\"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe\" --disk-cache-size=41943040 --user-data-dir=\"D:\\tools\\Chrome\\Data\" -- \"%1\""

[HKEY_CLASSES_ROOT\ftp\shell\open\command]
@="\"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe\" --disk-cache-size=41943040 --user-data-dir=\"D:\\tools\\Chrome\\Data\" -- \"%1\""

这里把datadir设到d:\tools\Chrome\Data里头。

当然还要改变快捷方式，将Target(目标)改为：
"C:\Program Files\Google\Chrome\Application\chrome.exe" --disk-cache-size=41943040 --user-data-dir="D:\tools\Chrome\Data"

c++和c#访问mysql的简单代码示例

2012-03-04T23:31:00.000-08:00

贴一份示例代码。

1) C#访问mysql

using System;
using System.Collections.Generic;
using System.Text;

using MySql.Data.MySqlClient;
using System.Data;
using System.Data.Common;

namespace SybaseUtilTest
{
    class Program
    {
        // http://bugs.mysql.com/47422
        static void testDataAdapter()
        {
            try
            {
                MySqlClientFactory factory = MySqlClientFactory.Instance;
                DbConnection conn = factory.CreateConnection();
                conn.ConnectionString = string.Format("server={0};user id={1}; password={2}; database={3}; port={4}; pooling=false",
                            "localhost", "root", "passwd", "test", 3306);
                conn.Open();

                DbDataAdapter da = factory.CreateDataAdapter();

                da.SelectCommand = conn.CreateCommand();
                da.SelectCommand.CommandText = "select * from t12345";

                da.DeleteCommand = conn.CreateCommand();
                da.DeleteCommand.CommandText = "delete from t12345 where id = @id";

                DbParameter param = factory.CreateParameter();
                param.ParameterName = "@id";
                param.DbType = DbType.Int32;
                param.SourceColumn = "id";
                param.SourceVersion = DataRowVersion.Current;

                da.DeleteCommand.Parameters.Add(param);
                da.DeleteCommand.UpdatedRowSource = UpdateRowSource.None;

                DataTable dt = new DataTable("t12345");
                da.Fill(dt);

                int index = 0;
                foreach ( DataRow o in dt.Rows )
                {
                    if (o["id"].Equals(4))
                    {
                        Console.WriteLine(String.Format("index={0}, to delete id = 4, col2 = {1}" , index, o["col2"]));
                        break;
                    }
                    index++;
                }
                dt.Rows[index].Delete();
                da.Update(dt);
                dt.AcceptChanges();

                da.Dispose();
                conn.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Source + " "
                    + ex.Message + " "
                    + ex.StackTrace);
            }

        }

        static void Main(string[] args)
        {
            testDataAdapter();
        }
    }
}

2) C++访问：

#include <iostream>
#include <windows.h>
#include <mysql.h>
#include <string>
static const char host[32] = "localhost";
static const char user[32] = "test";
static const char passwd[32] = "passwd";
static const char db[32] = "test";
/**
mysql> select * from t;
+----+
| id |
+----+
| 1 |
+----+
1 row in set (0.00 sec)
mysql> delimiter //
mysql> create procedure get_t(in t1 int)
 -> begin
 -> select id from t where id=t1;
 -> end
 -> //
Query OK, 0 rows affected (0.05 sec)
mysql> call get_t(1);
 -> //
+----+
| id |
+----+
| 1 |
+----+
1 row in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
*/
void test_more_results(MYSQL* h)
{
 char str[512] = "insert into test_num values(101);insert into test_num values(122);commit;";
 int r = mysql_real_query(h, str, strlen(str));
 if (r)
 {
 const char * error = mysql_error(h);
 std::cout<<"*** Connection Error " << error << std::endl;
 }
 do
 {
 MYSQL_RES* res = mysql_store_result(h);
 mysql_free_result(res);
 }
 while ( (0 == mysql_next_result(h)) );

}
void test_proc_stmt(MYSQL* h)
{
 MYSQL* mysql_ = h;
 MYSQL_BIND bind;
 MYSQL_BIND obind[1];
 // test_more_results(mysql_);
 MYSQL_STMT *hStmt = mysql_stmt_init(mysql_);
 my_bool true_value= 1;
 mysql_stmt_attr_set(hStmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &true_value);
 char sql[] = "call get_t(?)";
 //char sql[] = "select id from t where id=?";
 if (mysql_stmt_prepare(hStmt, sql, strlen(sql)))
 {
 std::cout<<__LINE__<<": stmt prepare error: "<< (mysql_stmt_error(hStmt))<<std::endl;
 mysql_stmt_reset(hStmt);
 if (mysql_stmt_prepare(hStmt, sql, strlen(sql)))
 {
 std::cout<<__LINE__<<": stmt prepare error: "<< (mysql_stmt_error(hStmt))<<std::endl;
 mysql_close(mysql_);
 exit( -1);
 }
 }
 int id = 1;
 unsigned long id_len = 0;
 memset(&bind, 0, sizeof(bind));
 bind.buffer_type = FIELD_TYPE_LONG;
 bind.buffer = (void*)&id;
 bind.is_unsigned = true;
 bind.length = &id_len;
 // bind[0].buffer_length = sizeof(id);
 // bind[0].is_null = 0;

 if (mysql_stmt_bind_param(hStmt,(MYSQL_BIND*)(&bind)) != 0)
 {
 std::cout<<__LINE__<<": stmt prepare error: "<< (mysql_stmt_error(hStmt))<<std::endl;
 mysql_close(mysql_);
 exit( -1);
 }
 if (mysql_stmt_execute(hStmt) != 0)
 {
 std::cout<<__LINE__<<": stmt prepare error: "<< (mysql_stmt_error(hStmt))<<std::endl;
 mysql_close(mysql_);
 exit( -1);
 }
 int t2;
 memset(obind, 0, sizeof(obind));
 obind[0].buffer_type= MYSQL_TYPE_LONG;
 obind[0].buffer= (char *)&t2;
 obind[0].buffer_length = sizeof(t2);

 if (mysql_stmt_bind_result(hStmt, (MYSQL_BIND*)&obind[0]) != 0)
 {
 std::cout<<__LINE__<<": stmt prepare error: "<< (mysql_stmt_error(hStmt))<<std::endl;
 mysql_close(mysql_);
 exit( -1);
 }
 if ( mysql_stmt_store_result(hStmt) != 0 )
 {
 std::cout<<__LINE__<<": stmt prepare error: "<< (mysql_stmt_error(hStmt))<<std::endl;
 mysql_close(mysql_);
 exit( -1);
 }


 int rows = mysql_stmt_num_rows(hStmt);
 for (int i=0; i<rows; i++)
 {
 if (mysql_stmt_fetch(hStmt) == 0)
 {
 std::cout<<"id = "<<t2<<std::endl;
 }
 }
 mysql_stmt_free_result(hStmt);
 mysql_stmt_close(hStmt);
}
//
// Just for demo only.
//
int main()
{
 MYSQL* mysql_ = NULL;
 MYSQL_RES* result_ = NULL;
 MYSQL_ROW row_;
 mysql_ = mysql_init(mysql_);
 // if (mysql_real_connect(mysql_, host, user, passwd, db, 3306, NULL, CLIENT_MULTI_STATEMENTS) == NULL)
 if (mysql_real_connect(mysql_, host, user, passwd, db, 3306, NULL, CLIENT_MULTI_STATEMENTS) == NULL)
 {
 const char * error = mysql_error(mysql_);
 std::cout<<"*** Connection Error " << error << std::endl;
 return -1;
 }
 mysql_autocommit(mysql_, false);
 std::string encodeStr = "set names 'gbk'";
 mysql_real_query(mysql_, encodeStr.c_str(), encodeStr.size());

 /*
 const char* tmpTableName = "t"; // assume you are querying the table 't'
 char str[512];
 int cnt = 0;
 sprintf(str,"select count(*) as cnt from %s", tmpTableName);
 mysql_real_query(mysql_, str, strlen(str));
 result_ = mysql_store_result(mysql_);
 while (row_ = mysql_fetch_row(result_))
 {
 // get the field value
 if (row_[0])
 {
 std::cout<<"count = "<<row_[0]<<std::endl;
 // convert it into int
 cnt = atoi(row_[0]);
 std::cout<<"cnt value = "<<row_[0]<<std::endl;
 }
 }
 mysql_free_result(result_);
 test_more_results();
 */
 test_proc_stmt(mysql_);

 do
 {
 MYSQL_RES* res = mysql_store_result(mysql_);
 mysql_free_result(res);
 }
 while ( (0 == mysql_next_result(mysql_)) );

 test_proc_stmt(mysql_);
 mysql_close(mysql_);
 return 0;
}

oracle10g server for win32的简装版(共50M)

2012-03-04T23:29:00.000-08:00

本文为原创，如若转载本文，请尊重个人劳动，务必附上本文链接地址：
http://hi.baidu.com/hexiong/blog/item/70c00a7bd40392f80ad1870a.html
作者：iihero@CSDN, hexiong@baidu

下载地址：
http://download.csdn.net/source/2405299
http://download.csdn.net/source/2405301

上一次整理这种工具已经是4年以前了。
重新弄了一下。原理比较简单。
1. 只要DB server所需要的主要目录及文件
2. 使用一个批处理文件一次性安装，无需安装程序.
3. 安装或携带非常方便, 尤其是对开发人员而言

有时间再试验11g for win32上的。以下是readme。
(免责声明):
这是一个精简版的oracle10g for windows 32平台.
此压缩包，仅供学习研究使用，本文作者不负任何责任。切不可将其用于商业用途，请遵守
Oracle公司相关商业规定。如因私自将其用于商业用途，由此带来的法律纠纷或其它问题，
概与本人无关.
author: iihero@CSDN (iiihero AT hotmail.com, iihero AT qq.com)

0. 如果你已经安装了别的版本的oracle，
请自行备份注册表:[HKEY_LOCAL_MACHINE/SOFTWARE/ORACLE], 这样即算有冲突，
你也可以重新导入以前的注册项而得已恢复

1. 将压缩包解压至目录，设该目录值为: <D>
其下将有目录：
<D>/oracle/*
<D>/oracle/10.1.0

2. 新的ORACLE_HOME将为：<D>/oracle/10.1.0
运行完iihero.ora10g.bat安装完以后，(一个批处理一次安装全部完成)
你需要将<D>/oracle/10.1.0/BIN添加到path里头
缺省的ORACLE_SID为iihero

3. 安装完以后，别忘了添加环境变量ORACLE_SID=iihero以及将%ORACLE_HOME%/bin
添加到PATH环境变量里头，在这之后，
即可使用sqlplus system/manager进入并修改密码，执行相关操作。

欢迎大家试用，如果发现有什么问题，可以与本人联系。

Ultraedit使用技巧小结

2012-03-04T23:27:00.001-08:00

来自我在百度上的同名短文。作者：hexiong　
版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明。http://hi.baidu.com/hexiong/blog/item/f9bbf01f3a4c1ef4e0fe0bdf.html
从Ultraedit8.0一直使用到现在，感觉这个东东确实不错。现将一些基本的经验总结如下，与大家共享；欢迎有兴趣的朋友前来补充。
Tip 0: 没有注册码，如何有效使用Ultraedit呢？
很多人立即想到使用crack版，可实际追究起来，那是违法的事情。实际上，Ultraedit并没有把路子完全堵死。我们可以使用一些小技巧来屏蔽掉这个问题。
修改ultraedit的快捷方式，将命令行改为：E:/uedit9/UEDIT32.EXE p:，其中p:必须是你的机器上不存在的分驱，这样，就不会有试用时间结束的问题了。

Tip 1: 如何去掉所编辑文本中包含特定字符串的行?　
这则技巧是在UltraEdit的帮助文件里提到．CTRL+R 调出来替换(Replace)窗口,选中"使用正则表达式";然后用查找 %*你的字符串*^p 替换成空内容即可.如，我当前有个文本文件，需要去掉所有包含 http://www.baidu.net/ 这个字符串的行，查找　%*http://www.baidu.net/*^p　替换成空即可．注意,^p 是 DOS 文件类型的换行符．如果是 Unix 类型文件，则用 ^n.

Tip 2: 如何在行末添加特定字符，比如逗号?
有了上面的经验(其实我第一次是从同事那里学到的)，CTRL+R 调出来替换(Replace)窗口,选中"使用正则表达式".然后可以查找 ^p(或者^n,如果是Unix 文件),用 ,^p(或者,^n)进行"全部替换"即可.补充一点，如果是 MAC(Apple) 类型文件,则换行符号为 ^r .

Tip 3: 如何删除空行?
参考上面两个例子,查找 ^p$ 然后替换为空即可．

看来，正则表达式需要学习一下喽．

Tip 4: 编辑文件如何加入时间戳 ?
F7　快捷键即可．你试试看?

Tip 5: 为何拷贝(Copy)/粘贴(Paste)功能不能用了?
不怕大家笑话，我有几次使用 UltraEdit 的过程中发现拷贝与粘贴的内容是不匹配的．不知所以然，干脆重新启动了笔记本.今天翻看手册才恍然大悟:UltraEdit有10个剪切板(clipboard),分别用Ctrl+0 - Ctrl+9　切换． Ctrl+0 是　Windows 的，其他则为用户自定义的．我在使用的过程中错调用了 CTRL+n, 结果内容就有问题了．你遇到过没?

Tip 6: 即使是打开小文件也有迟延?
这是我遇到过的问题．每次打开文件的时候总有几秒钟的耽搁．我的机器性能可不算差．怎么回事? 网络打印机搞得鬼! 打开"高级"->"设置"->"编辑器"->"高级",看看是不是选中了"载入/恢复打印机设置"?如果是的话，去掉(不同的版本/汉化与否可能该位置所在有差别)．

Tip 7: 删除当前行内容 CTRL+e

Tip 8: 你按一下快捷键ALT+c试试，变为列编辑模式，可以一次输入多行内容，只要你选好行范围，编辑整齐的数据表非常合适。

Tip 9: 光标位于某一行，按Ctrl+F2试试，有了标签了，多设几个，按住F2，它会往你设定的标签处跳来跳去，很好玩。

Tip 10: 暂时没想出来，有兴趣的前来补充。
更多内容整理中......

embedded_mysql:成功实验程序实现Embedded MySQL Server启动(C/C++)

2012-03-04T23:25:00.001-08:00

今天，碰巧有人问，说写的代码server_init，老是失败，我不信，试了一番，大费周折，总算成功。

有兴趣的，不妨自己动手一试，蛮有意思的。

我机器上原本有一个解压缩版的MySQL5.0.9，位于D:/program/mysql-5.0.9-beta-win32，默认存储引擎是InnoDB

1. 为便于测试，首先建立一个测试表，并插入几条记录，引擎定为MyISAM

create table t2(id int primary key, col2 varchar(32)) engine=MyISAM;

2. 创建Embed　Server的配置文件，

D:/program/mysql-5.0.9-beta-win32/Embedded/my.ini，值得一提的是，差点把我害惨了，就是Server那一项的名字必须与你的Server程序的名字保持一致。这里，EmbedMySQLServer就是我后边的exe程序的名，否则server永远也启不来。

内容如下：

[EmbedMySQLServer]
basedir = D:/program/mysql-5.0.9-beta-win32
datadir = D:/program/mysql-5.0.9-beta-win32/data
language = D:/program/mysql-5.0.9-beta-win32/share/english
skip-innodb
port=3306

[libmysqld_client]
language = D:/program/mysql-5.0.9-beta-win32/share/english
port=3306

3. 开始写自己的代码了

create EmbedMySQLServer.exe, source code like:

// #define _WIN32_WINNT 0x0400
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "mysql.h"
MYSQL *mysql;
MYSQL_RES *results;
MYSQL_ROW record;
#pragma comment(lib, "D://program//mysql-5.0.9-beta-win32//Embedded//DLL//debug//libmysqld.lib")
static char *server_options[] = { "mysql_test", "--defaults-file=D:/program/mysql-5.0.9-beta-win32/Embedded/my.ini" };
int num_elements = sizeof(server_options)/ sizeof(char *);
static char *server_groups[] = { "EmbedMySQLServer", "libmysqld_client" };
int main(void)
{
   int ret = mysql_server_init(num_elements, server_options, server_groups);
   printf("return %ld/n", ret);
   mysql = mysql_init(NULL);
   mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "libmysqld_client");
   mysql_options(mysql, MYSQL_OPT_USE_EMBEDDED_CONNECTION, NULL);
   MYSQL* t = mysql_real_connect(mysql, NULL,"test","test", "test", 0,NULL,0);
   
   mysql_query(mysql, "SELECT id, col2 FROM t2");
   results = mysql_store_result(mysql);
   while((record = mysql_fetch_row(results))) {
      printf("%s - %s /n", record[0], record[1]);
   }
   mysql_free_result(results);
   mysql_close(mysql);
   mysql_server_end();
   return 0;
}

4. 最终运行结果：

return 0
1 - test
2 - test
3 - test
4 - test
5 - fdas
Press any key to continue

像这类东东，MySQL Online Doc都没好好说，它都推荐买它的商业license，看来自己多动动手，也蛮有意思的。