问题:左边的SQL语句解析成右边的形式
Select c1,c2,c3 From t1,t2,t3 Where condi1=5 and condi6=6 or condi7=7 Group by g1,g2,g3 order by g2,g3
select
c1,
c2,
c3
from
t1,
t2,
t3
where
condi1=5 and
condi6=6 or
condi7=7
group by
g1,
g2,
g3
order by
g2,
g3
按关键字扑ևSQL语句中各部分
我们阅读SQL语句会把整句分来成列,?条g,分组字段,排序字段来理?解析SQL的目的也是这?
分解SQL语句有规律可?以列Z,它必定包含在select和from之间,我们只要能找到SQL语句中的关键字select和from,p扑ֈ查询的列.
怎么扑ֈselect和from之间的文字呢?其实一个正则表辑ּp解决:(select)(.+)(from),其中W二l?.+)代表的文字就是select和from之间的文?
E序见右?
/**
* 从文本text中找到regex首次匚w的字W串Q不区分大小?br />
* @param regexQ?正则表达?br />
* @param textQ欲查找的字W串
* @return regex首次匚w的字W串Q如未匹配返回空
*/
private static String getMatchedString(String regex,String text){
Pattern pattern=Pattern.compile(regex,Pattern.CASE_INSENSITIVE);
Matcher matcher=pattern.matcher(text);
while(matcher.find()){
return matcher.group(2);
}
return null;
}
解析函数分析
private static String getMatchedString(String regex,String text){
Pattern pattern=Pattern.compile(regex,Pattern.CASE_INSENSITIVE);
Matcher matcher=pattern.matcher(text);
while(matcher.find()){
return matcher.group(2);
}
return null;
}
左边的这个函?W一个参数是拟定的正则表辑ּ,W二个是整个SQL语句.
当正则表辑ּ?select)(.+)(from)?E序在SQL中查扄一ơ匹配的地方(有Pattern.CASE_INSENSITIVE的设|?查找不区分大写),如果扑ֈ了则q回模式中的W二l代表的文字.
如果sql是select a,b from tc,则返回的文字是a,b.
选择的表对应的查找正则表辑ּ
选择的表比较Ҏ(gu),它不想选择的列一样固定处于select和from之间,当没有查找条件存在时,它处于from和结束之?当有查找条g存在?它处于from和where之间.
因此查询函数写ؓ双的Ş?
/**
* 解析选择的表
*
*/
private void parseTables(){
String regex="";
if(isContains(sql,"\\s+where\\s+")){
regex="(from)(.+)(where)";
}
else{
regex="(from)(.+)($)";
}
tables=getMatchedString(regex,sql);
}
isContains函数
isContains函数用于在lineText中查找word,其中不区分大些,只要扑ֈ了即q回?
/**
* 看word是否在lineText中存在，支持正则表达?br />
* @param lineText
* @param word
* @return
*/
private static boolean isContains(String lineText,String word){
Pattern pattern=Pattern.compile(word,Pattern.CASE_INSENSITIVE);
Matcher matcher=pattern.matcher(lineText);
return matcher.find();
}
解析查找条g的函?/strong>
private void parseConditions(){
String regex="";
if(isContains(sql,"\\s+where\\s+")){
// 包括WhereQ有条g
if(isContains(sql,"group\\s+by")){
// 条g在where和group by之间
regex="(where)(.+)(group\\s+by)";
}
else if(isContains(sql,"order\\s+by")){
// 条g在where和order by之间
regex="(where)(.+)(order\\s+by)";
}
else{
// 条g在where到字W串末尾
regex="(where)(.+)($)";
}
}
else{
// 不包括where则条件无从谈Pq回卛_
return;
}
conditions=getMatchedString(regex,sql);
}
解析GroupBy的字D?/strong>
private void parseGroupCols(){
String regex="";
if(isContains(sql,"group\\s+by")){
// 包括GroupByQ有分组字段
if(isContains(sql,"order\\s+by")){
// group by 后有order by
regex="(group\\s+by)(.+)(order\\s+by)";
}
else{
// group by 后无order by
regex="(group\\s+by)(.+)($)";
}
}
else{
// 不包括GroupBy则分l字D|从谈Pq回卛_
return;
}
groupCols=getMatchedString(regex,sql);
}
解析OrderBy的字D?/strong>
private void parseOrderCols(){
String regex="";
if(isContains(sql,"order\\s+by")){
// 包括order byQ有分组字段
regex="(order\\s+by)(.+)($)";
}
else{
// 不包括GroupBy则分l字D|从谈Pq回卛_
return;
}
orderCols=getMatchedString(regex,sql);
}
得到解析后的各部?/strong>
按以上解析方法获得了??条g,分组条g,排序条g各部分之?它们会存储到各个成员变量?
注意q些成员变量的原值都是null,如果在SQL语句中能够找到对应的部分的话它们借助getMatchedString获得?否则q是null.我们通过判断q些成员变量是否为空p知道它对应的部分是否被解析出?
/**
* 待解析的SQL语句
*/
private String sql;
/**
* SQL中选择的列
*/
private String cols;
/**
* SQL中查扄?br />
*/
private String tables;
/**
* 查找条g
*/
private String conditions;
/**
* Group By的字D?br />
*/
private String groupCols;
/**
* Order by的字D?br />
*/
private String orderCols;
取得不需要单行显C时的SQL语句
q展到这一?SQL语句中列,?条g,分组条g,排序条g各部分都被获取了出来,q时把它们重新组合一下就能得到整理后的SQL语句.
如下面的SQL语句变成右边的部分(先静态成员isSingleLine=false):
Select c1,c2,c3 From t1,t2,t3 Where condi1=5 and condi6=6 or condi7=7 Group by g1,g2,g3 order by g2,g3
select
c1,c2,c3
from
t1,t2,t3
where
condi1=5 and condi6=6 or condi7=7
group by
g1,g2,g3
order by
g2,g3
q一步解?/strong>
有时我们需要把??条g,分组条g,排序条g单行昄以方便查看或加上注释,q就要求我们对列,?条g,分组条g,排序条g{进行进一步解?
初看解析很方?以固定的分隔W劈分即?但需要注意的是查询条件中分隔W有and和or两种,如果贸然分隔会重新l合时SQLq.
推荐一U做?我们可以在分隔符后加上一个标志如I,然后再以q个标志来劈?q样׃会SQLq?
误下页的getSplitedParagraph函数.
getSplitedParagraph函数
private static List<String> getSplitedParagraph(String paragraph,String splitStr){
List<String> ls=new ArrayList<String>();
// 先在分隔W后加空?br />
Pattern p = Pattern.compile(splitStr,Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(paragraph);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
while (result) {
m.appendReplacement(sb, m.group(0) + Crlf);
result = m.find();
}
m.appendTail(sb);
// 再按I格断行
String[] arr=sb.toString().split("[\n]+");
for(String temp:arr){
ls.add(FourSpace+temp+Crlf);
}
return ls;
}
处理l果
把静态成员变量isSingleLine=true后我们来看看执行l果:
select
c1,
c2,
c3
from
t1,
t2,
t3
where
condi1=5 and
condi6=6 or
condi7=7
group by
g1,
g2,
g3
order by
g2,
g3
结
从这个例子中我们体会了分ȝ思想:分治是把一个大问题分解成小问题,然后分别解决问?再组合v来大问题的解x法就差不多了.q种思想在工E领域解决问题时很普?我们要学会用这U思想来看?分析和解决问?不要贪多求大,l果D在大问题面前一{莫?
其次我们可以从这个例子中学习找规?然后借助规律的过E?现实世界千变万化,但都有规律可?只要我们扑ֈ了规?q于找C事物之门的钥?
接下了我们复习了正则表达式用于查扄Ҏ(gu),以前的正则表辑ּ学习多用于验证匹?其实q只是正则表辑ּ的一部分功能.
最后从解析条g成单行的q程?我们可以学习CU解决问题的技?卛_现实中的规律存在变数时加入h|的规律,q有时能使我们更好更快的解决问题.
]]>
java.util.regex介绍
java.util.regex是一个用正则表达式所订制的模式来对字W串q行匚w工作的类库包。它包括两个c：Pattern和Matcher Pattern .
Pattern是一个正则表辑ּl编译后的表现模式?nbsp;
Matcher 一个Matcher对象是一个状态机器，它依据Pattern对象做ؓ匚w模式对字W串展开匚w查。首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经~译后的模式Q然后一个Matcher实例在这个给定的Pattern实例的模式控制下q行字符串的匚w工作?/p>
Patternc?/strong>
在java?通过适当命名的Patterncd以容易确定String是否匚w某种模式.模式可以象匹配某个特定的String那样?也可以很复杂,需要采用分l和字符c?如空?数字,字母或控制符.因ؓJava字符串基于统一字符~码(Unicode),正则表达式也适用于国际化的应用程?
Pattern的方?/strong>
Pattern的方法如下： static Pattern compile(String regex)
给定的正则表达式编译ƈ赋予lPatternc?nbsp;
static Pattern compile(String regex, int flags)
同上Q但增加flag参数的指定，可选的flag参数包括QCASE INSENSITIVE,MULTILINE,DOTALL,UNICODE CASEQ?CANON EQ
int flags()
q回当前Pattern的匹配flag参数.
Matcher matcher(CharSequence input)
生成一个给定命名的Matcher对象
static boolean matches(String regex, CharSequence input)
~译l定的正则表辑ּq且对输入的字串以该正则表达式ؓ模开展匹?该方法适合于该正则表达式只会用一ơ的情况Q也是只进行一ơ匹配工作，因ؓq种情况下ƈ不需要生成一个Matcher实例?nbsp;
String pattern()
q回该Patter对象所~译的正则表辑ּ?nbsp;
String[] split(CharSequence input)
目标字W串按照Pattern里所包含的正则表辑ּ为模q行分割?nbsp;
String[] split(CharSequence input, int limit)
作用同上Q增加参数l(f)imit目的在于要指定分割的D|Q如limi设ؓ2Q那么目标字W串根据正则表辑ּ分ؓ割ؓ两段?nbsp;
一个正则表辑ּQ也是一串有特定意义的字W，必须首先要编译成Z个Patterncȝ实例Q这个Pattern对象会使用matcher()Ҏ(gu)来生成一个Matcher实例Q接着便可以用该 Matcher实例以编译的正则表达式ؓ基础对目标字W串q行匚w工作Q多个Matcher是可以共用一个Pattern对象的?
Matcher的方?/strong>
Matcher appendReplacement(StringBuffer sb, String replacement)
当前匹配子串替换ؓ指定字符Ԍq且替换后的子串以及其之前Cơ匹配子串之后的字符串段dC个StringBuffer对象里?
StringBuffer appendTail(StringBuffer sb)
最后一ơ匹配工作后剩余的字W串dC个StringBuffer对象里?
int end()
q回当前匚w的子串的最后一个字W在原目标字W串中的索引位置 ?
int end(int group)
q回与匹配模式里指定的组相匹配的子串最后一个字W的位置?
boolean find()
试在目标字W串里查找下一个匹配子丌Ӏ?
boolean find(int start)
重设Matcher对象Qƈ且尝试在目标字符串里从指定的位置开始查找下一个匹配的子串?
String group()
q回当前查找而获得的与组匚w的所有子串内?
String group(int group)
q回当前查找而获得的与指定的l匹配的子串内容
int groupCount()
q回当前查找所获得的匹配组的数量?
boolean lookingAt()
目标字W串是否以匹配的子串起始?
boolean matches()
试Ҏ(gu)个目标字W展开匚w，也就是只有整个目标字W串完全匚w时才q回真倹{?
Pattern pattern()
q回该Matcher对象的现有匹配模式，也就是对应的Pattern 对象?
String replaceAll(String replacement)
目标字W串里与既有模式相匹配的子串全部替换为指定的字符丌Ӏ?
String replaceFirst(String replacement)
目标字W串里第一个与既有模式相匹配的子串替换为指定的字符丌Ӏ?
Matcher reset()
重设该Matcher对象?
Matcher reset(CharSequence input)
重设该Matcher对象q且指定一个新的目标字W串?
int start()
q回当前查找所获子串的开始字W在原目标字W串中的位置?
int start(int group)
q回当前查找所获得的和指定l匹配的子串的第一个字W在原目标字W串中的位置?
一个Matcher实例是被用来对目标字W串q行Z既有模式Q也是一个给定的Pattern所~译的正则表辑ּQ进行匹配查扄Q所有往 Matcher的输入都是通过CharSequence接口提供的，q样做的目的在于可以支持对从多元化的数据源所提供的数据进行匹配工作?/p>
使用PatterncL验字W匹?/strong>
正则式是最单的能准匹配一个给定String的模?模式与要匚w的文本是{h(hun)?静态的Pattern.matchesҎ(gu)用于比较一个String是否匚w一个给定模?例程如下:
String data="java";
boolean result=Pattern.matches("java",data);
字符cd表示ơ数的特D字W?/p>
对于单字W串比较而言,使用正则表达式没有什么优?Regex的真正强大之处在于体现在包括字符cd量词(*,+,?)的更复杂的模式上.
字符cd?
\d 数字
\D 非数?br />
\w 单字字符(0-9,A-Z,a-z)
\W 非单字字W?br />
\s I白(I格W?换行W?回RW?制表W?
\S 非空?br />
[] 由方括号内的一个字W列表创建的自定义字W类
. 匚wM单个字符
下面的字W将用于控制一个子模式应用到匹配次数的q程.
? 重复前面的子模式0ơ到一?br />
* 重复前面的子模式0ơ或多次
+ 重复前面的子模式一ơ到多次
复杂匚w例一:重复ơ数匚w
String[] dataArr = { "moon", "mon", "moon", "mono" };
for (String str : dataArr) {
String patternStr="m(o+)n";
boolean result = Pattern.matches(patternStr, str);
if (result) {
System.out.println("字符?+str+"匚w模式"+patternStr+"成功");
}
else{
System.out.println("字符?+str+"匚w模式"+patternStr+"p|");
}
}
模式?#8221;m(o+)n”,它表Cmn中间的o可以重复一ơ或多次,因此moon,mon,mooon能匹配成?而mono在n后多了一个o,和模式匹配不?
?
+表示一ơ或多次;?表示0ơ或一?*表示0ơ或多次.
复杂匚w?单个字符匚w
String[] dataArr = { "ban", "ben", "bin", "bon" ,"bun","byn","baen"};
for (String str : dataArr) {
String patternStr="b[aeiou]n";
boolean result = Pattern.matches(patternStr, str);
if (result) {
System.out.println("字符?+str+"匚w模式"+patternStr+"成功");
}
else{
System.out.println("字符?+str+"匚w模式"+patternStr+"p|");
}
}
?Ҏ(gu)号中只允许的单个字符,模式“b[aeiou]n”指定,只有以b开?nl尾,中间是a,e,i,o,u中Q意一个的才能匚w?所以数l的前五个可以匹?后两个元素无法匹?
Ҏ(gu)号[]表示只有其中指定的字W才能匹?
复杂匚w?多个字符匚w
String[] dataArr = { "been", "bean", "boon", "buin" ,"bynn"};
for (String str : dataArr) {
String patternStr="b(ee|ea|oo)n";
boolean result = Pattern.matches(patternStr, str);
if (result) {
System.out.println("字符?+str+"匚w模式"+patternStr+"成功");
}
else{
System.out.println("字符?+str+"匚w模式"+patternStr+"p|");
}
}
如果需要匹配多个字W?那么[]׃能用上了,q里我们可以?)加上|来代?()表示一l?|表示或的关系,模式b(ee|ea|oo)np匚wbeen,bean,boon{?
因此前三个能匚w?而后两个不能.
复杂匚w?数字匚w
String[] dataArr = { "1", "10", "101", "1010" ,"100+"};
for (String str : dataArr) {
String patternStr="\\d+";
boolean result = Pattern.matches(patternStr, str);
if (result) {
System.out.println("字符?+str+"匚w模式"+patternStr+"成功");
}
else{
System.out.println("字符?+str+"匚w模式"+patternStr+"p|");
}
}
?从前面可以知?\\d表示的是数字,?表示一ơ或多次,所以模式\\d+pCZ位或多位数字.
因此前四个能匚w?最后一个因?h非数字字W而匹配不?
复杂匚w?字符数字混合匚w
String[] dataArr = { "a100", "b20", "c30", "df10000" ,"gh0t"};
for (String str : dataArr) {
String patternStr="\\w+\\d+";
boolean result = Pattern.matches(patternStr, str);
if (result) {
System.out.println("字符?+str+"匚w模式"+patternStr+"成功");
}
else{
System.out.println("字符?+str+"匚w模式"+patternStr+"p|");
}
}
模式\\w+\\d+表示的是以多个单字字W开?多个数字l尾的字W串,因此前四个能匚w?最后一个因为数字后q含有单字字W而不能匹?
使用正则表达式劈分字W串-使用字符串的splitҎ(gu)
String str="薪水,职位 姓名;q龄 性别";
String[] dataArr =str.split("[,\\s;]");
for (String strTmp : dataArr) {
System.out.println(strTmp);
}
Stringcȝsplit函数支持正则表达?上例中模式能匚w”,”,单个I格,”;”中的一?split函数能把它们中Q意一个当作分隔符,一个字W串劈分成字W串数组.
使用Pattern劈分字符?/strong>
String str="2007q?2?1?;
Pattern p = Pattern.compile("[q月日]");
String[] dataArr =p.split(str);
for (String strTmp : dataArr) {
System.out.println(strTmp);
}
Pattern是一个正则表辑ּl编译后的表现模?,它的splitҎ(gu)能有效劈分字W串.
注意其和String.split()使用上的不同.
使用正则表达式进行字W串替换
String str="10?1000人民?10000?100000RMB";
str=str.replaceAll("(\\d+)(元|人民币|RMB)", "$1K?);
System.out.println(str);
上例?模式“(\\d+)(元|人民币|RMB)”按括号分成了两组,W一l\\d+匚w单个或多个数?W二l匹配元,人民?RMB中的L一?替换部分$1表示W一个组匚w的部分不?其余l替换成K?
替换后的str为E10 K?000 K?0000 K?00000
使用matcherq行替换
Pattern p = Pattern.compile("m(o+)n",Pattern.CASE_INSENSITIVE);
// 用Patterncȝmatcher()Ҏ(gu)生成一个Matcher对象
Matcher m = p.matcher("moon mooon Mon mooooon Mooon");
StringBuffer sb = new StringBuffer();
// 使用find()Ҏ(gu)查找W一个匹配的对象
boolean result = m.find();
// 使用循环扑և模式匚w的内Ҏ(gu)换之,再将内容加到sb?br />
while (result) {
m.appendReplacement(sb, "moon");
result = m.find();
}
// 最后调用appendTail()Ҏ(gu)最后一ơ匹配后的剩余字W串加到sb里；
m.appendTail(sb);
System.out.println("替换后内Ҏ(gu)" + sb.toString());
使用Mather验证IP地址的有效?/p>
验证函数:
public static boolean isValidIpAddr(String ipAddr){
String regx="(\\d+).(\\d+).(\\d+) .(\\d+)";
if(Pattern.matches(regx, ipAddr)){
Pattern pattern=Pattern.compile(regx);
Matcher mather=pattern.matcher(ipAddr);
while(mather.find()){
for(int i=1;i<=mather.groupCount();i++){
String str=mather.group(i);
int temp=Integer.parseInt(str);
if(temp>255 || temp<1){
return false;
}
}
}
}
else{
return false;
}
return true;
}
执行语句:
String[] ipArr = { "1.2.3.4", "3.2.1.5", "999.244.17.200", "233.200.18.20",
"2.1.0.18", "0.2.1.19" };
for (String str : ipArr) {
if (isValidIpAddr(str)) {
System.out.println(str + "是合法的IP地址");
} else {
System.out.println(str + "不是合法的IP地址");
}
}
执行l果:
1.2.3.4是合法的IP地址
3.2.1.5是合法的IP地址
999.244.17.200不是合法的IP地址
233.200.18.20是合法的IP地址
2.1.0.18不是合法的IP地址
0.2.1.19不是合法的IP地址
]]>