sql语句解析实现

最新推荐文章于 2023-07-25 16:50:21 发布
最新推荐文章于 2023-07-25 16:50:21 发布
阅读量6.7k 收藏 11
点赞数 5
分类专栏： Java 文章标签： java sql 解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shirley_john_thomas/article/details/52486959
版权

第一步：先对sql语句进行预处理；

对于用户，我们应该接受各种形式的查询语句书写，单行或者多行，语句中单个空格或者多个空格的间隔等等。但是我们要解析sql语句，就首先要让对它们做标准化，这样才能进行我们下一步处理。系统中的处理要求：

1）消除SQL语句前后的空白，将其中的连续空白字符（包括空格，TAB和回车换行）替换成单个空格；

2）将sql语句全变成小写形式（或大写形式）；

3）在SQL语句的尾后加上结束符号“ENDOFSQL”（原因后面解释）

例如：用户输入：“select c1,c2,c3 from　　t1,t2,　t3 where condi1=5 and condi6=6 or condi7=7 order　

by g1,g2”

通过预处理应该为：“select c1,c2,c3 from t1,t2,t3 where condi1=5 and condi6=6 or condi7=7 order by g1,g2”

第二步：将查询语句切分为语句块；

以查询语句为例（本文中主要是以查询语句作为例子讲解，其它删除，插入等语句原理于此类似，因为查询语句相对复杂，所以用来i讲解），正如上面我们标准化后的语句一样，我们要进行下一步的，对表中数据的处理，首先要知道是对那些表处理，要满足那些条件，输出那些属性，以什么顺序输出等。所以查询语句就可以分割为以下几个块：

1）select c1,c2,c3 from：属性输出块；块头（start）select，块尾(end)from，这个块我们关心的信息(body)：c1,c2,c3；以下块类似分析

2）from....where; 涉及数据表块。

3）where.....order by; 查询条件块。

4）order by.....ENDOFSQL; 属性输出顺序。这里也就看出了我们为什么要在查询语句末尾加上结束符，是为了最后一个块的限定需要。

知道了如何分块，接下来要做的就是在我们已经标准化的sql语句上进行块的切割，这里我们用到了正则表达式，以第二个块from....where的查询为例，我们做个分析

"(from)(.+)( where | on | having | group by | order by | ENDOFSQL)“

以上就是第二个块的正则匹配式（其它块的匹配式下面也会给出），可以看出，在一个sql查询语句中，from块中跟from搭配出现的不只是where，还可以是on,having,group by等，那么通过这个正则式我们可以得到如下的块：

      from .... where

　　from .... on

　　from .... having

　　from .... group by

　　from .... order by

　　from .... ENDOFSQL

这里我们要注意一点，就是在通过正则式对sql语句进行匹配时，我们不能对整个sql语句进行一次匹配操作，因为正则匹配是贪心匹配，它总是尽可能的向后查找，匹配到最大的语句段。就拿上述语句为例，如果通过对整个sql语句进行一次匹配，得到的就不是from....where这个语句段而是from .... where .... order by。显然这不是我们想要的。所以我们只能牺牲效率，通过对整个sql语句进行逐次递增的查询方式来查找相应的语句块。给出一个查询过程，加强理解，以上述sql语句为例，对第一个语句块的查找过程是

s
se
sel
.............
select c1,c2,c3 from

这样就找到第一个块，以此类推，找第二个块时候又从头逐次递增查找。

第三步：找到了各个块，我们还要把我们最关心的信息提取出来，就是夹在语句块头和尾之间的body部分，这个就好实现了，一般的sql语句中都会用逗号来做分割，我们提取出各个块的body信息。

步骤介绍完了，下面就上代码!

package com.hz.util.sql;

import java.util.List;

/**
 * 单句sql解析器制造工厂
 * 
 * @author Blossom
 * @time 2016年9月9日
 */
public class SqlParserUtil {

	/**
	 * 方法的主要入口
	 * 
	 * @author Blossom
	 * @time 2016年9月9日
	 * @param sql
	 *            要解析的sql语句
	 * @return 返回解析结果
	 * @return_type String
	 *
	 */
	public String getParsedSql(String sql) {
		sql = sql.trim();
		sql = sql.toLowerCase();
		sql = sql.replace("\\s{1,}", " ");
		sql = "" + sql + " ENDOFSQL";
		return SingleSqlParserFactory.generateParser(sql).getParsedSql();
	}

	/**
	 * SQL语句解析的接口
	 * 
	 * @author Blossom
	 * @time 2016年9月9日
	 * @param sql
	 *            要解析的sql语句
	 * @return 返回解析结果
	 * @return_type List<SqlSegment>
	 *
	 */
	public List<SqlSegment> getParsedSqlList(String sql) {
		sql = sql.trim();
		sql = sql.trim();
		sql = sql.toLowerCase();
		sql = sql.replace("\\s{1,}", " ");
		sql = "" + sql + " ENDOFSQL";
		return SingleSqlParserFactory.generateParser(sql).returnSqlSegments();
	}

}

<pre name="code" class="java">package com.hz.util.sql;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * sql语句片段
 * 
 * @author Blossom
 * @time 2016年9月9日
 */
public class SqlSegment {
	private static final String Crlf = "@";
	private static final String FourSpace = "　　";
	// sql语句片段开头
	private String start;
	// sql语句片段中间部分
	private String body;
	// sql语句片段结束部分
	private String end;
	// 表示片段的正则表达式
	private String segmentRegExp;
	// 分割后的body小片段
	private List<String> bodyPieces;
	// 用于分割中间部分的正则表达式
	private String bodySplitPattern;

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 */
	public SqlSegment(String segmentRegExp, String bodySplitPattern) {
		start = "";
		body = "";
		end = "";
		this.segmentRegExp = segmentRegExp;
		this.bodySplitPattern = bodySplitPattern;
		this.bodyPieces = new ArrayList<>();
	}

	/**
	 * 从sql中查找符合segmentRegExp的部分,并赋值到start,body,end三个属性中
	 * 
	 * @author Blossom
	 * @time 2016年9月9日
	 * @param sql
	 * @return_type void
	 *
	 */
	public void parse(String sql) {
		Pattern pattern = Pattern.compile(segmentRegExp, Pattern.CASE_INSENSITIVE);
		for (int i = 0; i <= sql.length(); i++) {
			String shortSql = sql.substring(0, i);
			// 测试输出的子句是否正确 System.out.println(shortSql);
			Matcher matcher = pattern.matcher(shortSql);
			while (matcher.find()) {
				start = matcher.group(1);
				body = matcher.group(2);
				end = matcher.group(3);
				return;
			}
		}
	}

	/**
	 * 解析body片段
	 * 
	 * @author Blossom
	 * @time 2016年9月9日
	 * @return_type void
	 *
	 */
	@SuppressWarnings("unused")
	private void parseBody() {

		List<String> ls = new ArrayList<String>();
		Pattern p = Pattern.compile(bodySplitPattern, Pattern.CASE_INSENSITIVE);
		// 先清除掉前后空格
		body = body.trim();
		Matcher m = p.matcher(body);
		StringBuffer sb = new StringBuffer();
		boolean result = m.find();
		while (result) {
			m.appendReplacement(sb, m.group(0) + Crlf);
			result = m.find();
		}
		m.appendTail(sb);
		// 再按空格断行
		String[] arr = sb.toString().split(" ");
		int arrLength = arr.length;
		for (int i = 0; i < arrLength; i++) {
			String temp = FourSpace + arr[i];
			if (i != arrLength - 1) {
				// temp=temp+Crlf; }
				ls.add(temp);
			}
			bodyPieces = ls;
		}
	}

	/**
	 * 取得解析好的sql片段
	 * 
	 * @author Blossom
	 * @time 2016年9月9日
	 * @return
	 * @return_type String
	 *
	 */
	public String getParsedSqlSegment() {
		StringBuffer sb = new StringBuffer();
		sb.append(start + Crlf);
		for (String piece : bodyPieces) {
			sb.append(piece + Crlf);
		}
		return sb.toString();
	}

	/**
	 * @return the start
	 */
	public String getStart() {
		return start;
	}

	/**
	 * @param start
	 *            the start to set
	 */
	public void setStart(String start) {
		this.start = start;
	}

	/**
	 * @return the body
	 */
	public String getBody() {
		return body;
	}

	/**
	 * @param body
	 *            the body to set
	 */
	public void setBody(String body) {
		this.body = body;
	}

	/**
	 * @return the end
	 */
	public String getEnd() {
		return end;
	}

	/**
	 * @param end
	 *            the end to set
	 */
	public void setEnd(String end) {
		this.end = end;
	}

	/**
	 * @return the segmentRegExp
	 */
	public String getSegmentRegExp() {
		return segmentRegExp;
	}

	/**
	 * @param segmentRegExp
	 *            the segmentRegExp to set
	 */
	public void setSegmentRegExp(String segmentRegExp) {
		this.segmentRegExp = segmentRegExp;
	}

	/**
	 * @return the bodyPieces
	 */
	public List<String> getBodyPieces() {
		return bodyPieces;
	}

	/**
	 * @param bodyPieces
	 *            the bodyPieces to set
	 */
	public void setBodyPieces(List<String> bodyPieces) {
		this.bodyPieces = bodyPieces;
	}

	/**
	 * @return the bodySplitPattern
	 */
	public String getBodySplitPattern() {
		return bodySplitPattern;
	}

	/**
	 * @param bodySplitPattern
	 *            the bodySplitPattern to set
	 */
	public void setBodySplitPattern(String bodySplitPattern) {
		this.bodySplitPattern = bodySplitPattern;
	}

}

package com.hz.util.sql;

import java.util.ArrayList;
import java.util.List;

/**
 * 单句sql解析器,单句即非嵌套的意思
 * 
 * @author Blossom
 * @time 2016年9月9日
 */
public abstract class BaseSingleSqlParser {

	// 原始sql语句
	protected String originalSql;
	// sql语句片段
	protected List<SqlSegment> segments;

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 */
	public BaseSingleSqlParser(String originalSql) {
		this.originalSql = originalSql;
		segments = new ArrayList<>();
		initializeSegments();
		splitSqlToSegment();
	}

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @return_type void
	 *
	 */
	protected void splitSqlToSegment() {
		for (SqlSegment sqlSegment : segments) {
			sqlSegment.parse(originalSql);
		}
	}

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @return_type void
	 *
	 */
	protected abstract void initializeSegments();

	/**
	 * 得到解析完毕的Sql语句
	 * 
	 * @author Blossom
	 * @time 2016年9月9日
	 * @return
	 * @return_type String
	 *
	 */
	public String getParsedSql() {
		StringBuffer stringBuffer = new StringBuffer();
		for (SqlSegment sqlSegment : segments) {
			stringBuffer.append(sqlSegment.getParsedSqlSegment());
		}
		String result = stringBuffer.toString().replaceAll("@+", "\n");
		return result;
	}

	/**
	 * 得到解析的sql片段
	 * 
	 * @author Blossom
	 * @time 2016年9月9日
	 * @return
	 * @return_type List<SqlSegment>
	 *
	 */
	public List<SqlSegment> returnSqlSegments() {
		int segmentLength = this.segments.size();
		if (segmentLength != 0) {
			List<SqlSegment> result = this.segments;
			return result;
		}
		return null;
	}
}


package com.hz.util.sql;

/**
 * 单句删除语句解析
 * 
 * @author Blossom
 * @time 2016年9月9日
 */
public class DeleteSqlParser extends BaseSingleSqlParser {

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @param originalSql
	 */
	public DeleteSqlParser(String originalSql) {

		super(originalSql);

	}

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @see com.hz.util.sql.BaseSingleSqlParser#initializeSegments()
	 */
	@Override
	protected void initializeSegments() {
		segments.add(new SqlSegment("(delete from)(.+)(where | ENDOFSQL)", "[,]"));
		segments.add(new SqlSegment("(where)(.+)( ENDOFSQL)", "(and|or)"));
	}

}


package com.hz.util.sql;

/**
 * 单句查询插入语句解析器
 * 
 * @author Blossom
 * @time 2016年9月9日
 */
public class InsertSelectSqlParser extends BaseSingleSqlParser {

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @param originalSql
	 */
	public InsertSelectSqlParser(String originalSql) {

		super(originalSql);

	}

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @see com.hz.util.sql.BaseSingleSqlParser#initializeSegments()
	 */
	@Override
	protected void initializeSegments() {
		segments.add(new SqlSegment("(insert into)(.+)( select )", "[,]"));
		segments.add(new SqlSegment("(select)(.+)(from)", "[,]"));
		segments.add(new SqlSegment("(from)(.+)( where | on | having | groups+by | orders+by | ENDOFSQL)",
				"(,|s+lefts+joins+|s+rights+joins+|s+inners+joins+)"));
		segments.add(new SqlSegment("(where|on|having)(.+)( groups+by | orders+by | ENDOFSQL)", "(and|or)"));
		segments.add(new SqlSegment("(groups+by)(.+)( orders+by| ENDOFSQL)", "[,]"));
		segments.add(new SqlSegment("(orders+by)(.+)( ENDOFSQL)", "[,]"));
	}

}

package com.hz.util.sql;

/**
 * 单句插入语句解析
 * 
 * @author Blossom
 * @time 2016年9月9日
 */
public class InsertSqlParser extends BaseSingleSqlParser {

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @param originalSql
	 */
	public InsertSqlParser(String originalSql) {

		super(originalSql);

	}

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @see com.hz.util.sql.BaseSingleSqlParser#initializeSegments()
	 */
	@Override
	protected void initializeSegments() {
		segments.add(new SqlSegment("(insert into)(.+)([(])", "[,]"));
		segments.add(new SqlSegment("([(])(.+)( [)] values )", "[,]"));
		segments.add(new SqlSegment("([)] values [(])(.+)( [)])", "[,]"));
	}

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @return
	 * @see com.hz.util.sql.BaseSingleSqlParser#getParsedSql()
	 */
	@Override
	public String getParsedSql() {

		String result = super.getParsedSql();
		result += ")";

		return result;
	}

}

package com.hz.util.sql;

/**
 * 单句查询语句解析器
 * 
 * @author Blossom
 * @time 2016年9月9日
 */
public class SelectSqlParser extends BaseSingleSqlParser {

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @param originalSql
	 */
	public SelectSqlParser(String originalSql) {

		super(originalSql);

	}

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @see com.hz.util.sql.BaseSingleSqlParser#initializeSegments()
	 */
	@Override
	protected void initializeSegments() {
		segments.add(new SqlSegment("(select)(.+)(from)", "[,]"));
		segments.add(new SqlSegment("(from)(.+)( where | on | having | group by | order by | ENDOFSQL)",
				"(,| left join | right join | inner join )"));
		segments.add(new SqlSegment("(where|on|having)(.+)( group by | order by | ENDOFSQL)", "(and|or)"));
		segments.add(new SqlSegment("(group by)(.+)( order by| ENDOFSQL)", "[,]"));
		segments.add(new SqlSegment("(order by)(.+)( ENDOFSQL)", "[,]"));
	}

}

package com.hz.util.sql;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author Blossom
 * @time 2016年9月9日
 */
public class SingleSqlParserFactory {

	public static BaseSingleSqlParser generateParser(String sql) {
		if (contains(sql, "(insert into)(.+)(select)(.+)(from)(.+)")) {
			return new InsertSelectSqlParser(sql);
		} else if (contains(sql, "(select)(.+)(from)(.+)")) {
			return new SelectSqlParser(sql);
		} else if (contains(sql, "(delete from)(.+)")) {
			return new DeleteSqlParser(sql);
		} else if (contains(sql, "(update)(.+)(set)(.+)")) {
			return new UpdateSqlParser(sql);
		} else if (contains(sql, "(insert into)(.+)(values)(.+)")) {
			return new InsertSqlParser(sql);
		}

		return new InsertSqlParser(sql);
	}

	/**
	 * 看word是否在lineText中存在，支持正则表达式
	 * 
	 * @author Blossom
	 * @time 2016年9月9日
	 * @param sql
	 * @param regExp
	 * @return
	 * @return_type boolean
	 *
	 */
	private static boolean contains(String sql, String regExp) {
		Pattern pattern = Pattern.compile(regExp, Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher(sql);
		return matcher.find();
	}

}


package com.hz.util.sql;

/**
 * 单句更新sql语句
 * 
 * @author Blossom
 * @time 2016年9月9日
 */
public class UpdateSqlParser extends BaseSingleSqlParser {

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @param originalSql
	 */
	public UpdateSqlParser(String originalSql) {

		super(originalSql);

	}

	/**
	 * @author Blossom
	 * @time 2016年9月9日
	 * @see com.hz.util.sql.BaseSingleSqlParser#initializeSegments()
	 */
	@Override
	protected void initializeSegments() {
		segments.add(new SqlSegment("(update)(.+)(set)", "[,]"));
		segments.add(new SqlSegment("(set)(.+)( where | ENDOFSQL)", "[,]"));
		segments.add(new SqlSegment("(where)(.+)( ENDOFSQL)", "(and|or)"));
	}

}






 

 

 


                

        

        

    




    

      

        

            

              
                
                  番薯(Koali)
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    5
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    11
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  1
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
sql实现触发器.ppt

				
			

			

				

					11-15
				

			

		

		

			
				
sql实现触发器.ppt

			
		

	



                

              
                



	

		

			

				
					
使用SQL实现小计,合计以及排序

				
			

			

				

					09-10
				

			

		

		

			
				
本篇文章是对SQL实现小计,合计以及排序进行了详细的分析介绍，需要的朋友参考下

			
		

	



                


  
              

                


	

		

			

				
					
使用SQL语言实现数据库操作

					
最新发布

				
			

			

				

					anwen743680的博客
				

				

					07-25
					
					242
					
				

			

		

		

			
				
使用 SQL语言实现数据库操作

			
		

	





	

		

			

				
					
使用MySQL创建数据库并实现基本的SQL语句

				
			

			

				

					weixin_52687711的博客
				

				

					05-07
					
					6719
					
				

			

		

		

			
				
可以看到刚刚创建的表class_1中有属性sno，类型为int(11);有属性name ，类型为varchar(32);有属性phone，类型为int(11);有属性addr，类型为varchar(32)，都允许为空，但未设置主键，外键和默认值。指定位置：alter table 表名 add 属性名 类型 after 原有属性;语法：alter table 表名 change 原属性 修改后属性 类型;一起进步，共同学习交流！加到最后：alter table 表名 add 属性名 类型;

			
		

	



		

			
		



	

		

			

				
					
使用SQL语句创建数据库与创建表

					
热门推荐

				
			

			

				

					@初阶牛的博客
				

				

					11-28
					
					4万+
					
				

			

		

		

			
				
数据库基础知识讲解,包括创建数据库,修改数据库属性,数据库的分离与附加,创建数据表等操作.

			
		

	





	

		

			

				
					
mybatis plus中的${ew.sqlSegment}，${ew.sqlSelect}，${ew.customSqlSegment}使用

				
			

			

				

					m0_60721514的博客
				

				

					03-08
					
					1万+
					
				

			

		

		

			
				
ew是mapper方法里的@Param(Constants.WRAPPER) Wrapper queryWrapper对象
首先判断ew.emptyOfWhere是否存在where条件，有的话再拼接上去，ew.customSqlSegment是WHERE + sql语句
没有where的时候加上 == false
使用${ew.sqlSegment} 如果是连表查询且查询条件是连表的字段则需在service层拼接查询条件时字段前指定别名
最佳例子1
mapper.xml
 <select id="ta

			
		

	





	

		

			

				
					
Java 实现对Sql语句解析

				
			

			

				

					weixin_34117522的博客
				

				

					06-10
					
					627
					
				

			

		

		

			
				
最近要实现一个简易的数据库系统，除了要考虑如何高效的存储和访问数据，建立表关系外，对基本的sql查询语句要做一个解析，这样我们才能知道用户的查询要求；因为时间关系，参考了已有的一篇文章，并对其实现中出的小问题给予更正，在这里跟大家共享一下。原文请查阅http://www.cnblogs.com/pelephone/articles/sql-parse-single-word.html
第一步：先...

			
		

	





	

		

			

				
					
org.apache.ibatis.ognl.OgnlException: sqlSegment

				
			

			

				

					Laity
				

				

					07-19
					
					7326
					
				

			

		

		

			
				
Caused by: org.apache.ibatis.builder.BuilderException: Error evaluating expression 'ew.sqlSegment != null and ew.sqlSegment != '' and ew.nonEmptyOfNormal'. Cause: org.apache.ibatis.ognl.OgnlException: sqlSegment [java.lang.NullPointerException]

			
		

	





	

		

			

				
					
如何实现一个SQL解析器

				
			

			

				

					SmartSi
				

				

					12-31
					
					1025
					
				

			

		

		

			
				
在选择SQL解析器应用到我们实际的业务场景之前，我们先来了解一下SQL解析器的核心知识点。如何理解语法解析呢？语法解析我们可以这么来进行理解，在启动语法解析任务时，语法分析的任务会在词法分析的结果上将词条序列组合成不同语法短句，组成的语法短句将与相应的语法规则进行适配，若适配成功则生成对应的抽象语法树，否则报会抛出语法错误异常。比如如下SQL语句：SQL示例约定规则如下：上表中，红色的内容通常表示终结符，它们一般是大写的关键字或者符号等，小写的内容是非终结符，一般用作规则的命名，比如字段、表名等。

			
		

	





	

		

			

				
					
Mybatis-Plus 多表+分页+条件查询 实现

				
			

			

				

					mrorry的博客
				

				

					07-12
					
					3405
					
				

			

		

		

			
				
了解什么是MP一、${ew.customSqlSegment}和${ew.sqlSegment}是什么？1.写多表查询语句


			
		

	





	

		

			

				
					
oracle或db2的建表SQL语句解析

				
			

			

				

					05-16
				

			

		

		

			
				
读取oracle或db2的建表SQL语句文本文件(.txt)，解析后转为java对象且序列化后存为.dm文件

			
		

	





	

		

			

				
					
SQL语句的各个关键字的解析过程详细总结

				
			

			

				

					09-10
				

			

		

		

			
				
由于最近需要做一些sql query性能提升的研究，因此研究了一下sql语句的解析过程;本文是我在看了各种资料后手机总结的，会详细的，一步一步的讲述一个sql语句的各个关键字的解析过程，欢迎大家互相学习

			
		

	





	

		

			

				
					
ORM Django 终端打印 SQL 语句实现解析

				
			

			

				

					09-18
				

			

		

		

			
				
主要介绍了ORM Django 终端打印 SQL 语句实现解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

			
		

	





	

		

			

				
					
Mybatis中的动态SQL语句解析

				
			

			

				

					09-09
				

			

		

		

			
				
主要介绍了Mybatis中的动态SQL语句解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

			
		

	





	

		

			

				
					
DBMS.zip_C++_boost实现解析sql语句

				
			

			

				

					09-20
				

			

		

		

			
				
使用boost正则表达式实现c++解析sql语句，仅实现了insert/update/delete.

			
		

	





	

		

			

				
					
iText官方教程

				
			

			

				

					Shirley_John_Thomas的博客
				

				

					12-26
					
					1万+
					
				

			

		

		

			
				
如果要导出PDF文件，首选当然是iText，从网上也找了些资料，有很多，也有些乱。

自己做了个例子，感觉还是很浅，深入的内容还是研究不透。下载了官方的jar包，本来想看看

里面的Demo，结果只有api文档。资料还真是不好找。

今天发现官方还是有很多例子代码的。

下载地址：http://itextpdf.com/examples/

iText官网： http://it

			
		

	





	

		

			

				
					
windows7中安装jdk1.8

				
			

			

				

					Shirley_John_Thomas的博客
				

				

					10-08
					
					6199
					
				

			

		

		

			
				
一：JDK的安装


1.   首先上甲骨文公司的官方网站下载JDK的安装包，根据自己电脑的操作系统选择正确的版本下载。不知道下载地址的同学可以直接点击链接：http://www.Oracle.com/technetwork/Java/javase/downloads/jdk7-downloads-1880260.html。下载好的安装包如下图所示。




2.   用鼠标左键双

			
		

	





	

		

			

				
					
Java虚拟内存

				
			

			

				

					Shirley_John_Thomas的博客
				

				

					09-08
					
					4287
					
				

			

		

		

			
				
可以给Java虚拟机设置使用的内存，但是如果你的选择不对的话，虚拟机不会补偿。可通过命令行的方式改变虚拟机使用内存的大小。如下表所示有两个参数用来设置虚拟机使用内存的大小。 
参数描述 
-Xms JVM初始化堆的大小 
-Xmx JVM堆的最大值 

　　这两个值的大小一般根据需要进行设置。初始化堆的大小执行了虚拟机在启动时向系统申请的内存的大小。一般而言，这个参数不重要。但是有的应用

			
		

	





	

		

			

				
					
正则语句解析sql语句

				
			

			

				

					05-16
				

			

		

		

			
				
更好的方法是使用 SQL 解析器，它可以将 SQL 语句解析成语法树，然后可以对语法树进行操作。  如果你仍然想使用正则表达式来解析 SQL 语句，以下是一些可能有用的正则表达式：  1. 匹配 SELECT 语句中的字段列表：  ...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值