使用java sql parser插件(轉載)

JsqlParser插件用來對於SQL語句進行解析和組裝，將SQL語句關鍵詞之間的內容用List<String>進行保存，同時可以進行更改List<String>的內容後重新組裝成一個新的SQL語句。項目中的需求多用於更改SQL中table name。(其實感覺用正則會更好一點)

JsqlParser其實就是將sql語句各個關鍵詞用Java類的形式進行了對應解析，包括很多函數可以讓我們得到各個部分的內容。我目前只是簡單的測試使用，更深入的實現，比如javacc語法樹沒有了解太多。很簡單的東西，主要是關於JsqlParser類型轉換總結。

 

Parsing類以及其中函數說明：

   各個函數都有說明，參數Sting sql，得到List<String>或者String，不多說了，很簡單的東西

   TableNameFinder類多注意一些，很好使用，任何類型的SQL語句、無論是否包含嵌套SQL  此類的靜態函數都能將table name提取出來，後面直接使用String replace函數進行替換即可。

   不過有個bug，就是tablenamefinder只能得到所有不重複的表名tablename，如果發生重複只能得到一個，不能重複獲取，沒找到源碼出現這種情況的原因，留待以後學習多了再進行解決。
 

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.parser.CCJSqlParserManager;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.select.Join;
import net.sf.jsqlparser.statement.select.OrderByElement;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.statement.select.SelectItem;
import net.sf.jsqlparser.statement.update.Update;
import net.sf.jsqlparser.util.TablesNamesFinder;
 
public class Prasing_Test {
	//三個 sql語句 測試例子，select，insert，update
	//由已知的 sql語句 分別得到對應的 List<String> 或 String
 
	public static void test_select(String sql) throws JSQLParserException {
		// *********select body items內容
		List<String> str_items = Prasing_Test.test_select_items(sql);
 
		// **********select table
		List<String> tableList = Prasing_Test.test_select_table(sql);
 
		// **********select table with join
		List<String> tablewithjoin = Prasing_Test.test_select_join(sql);
		
		// // *******select where
		String str = Prasing_Test.test_select_where(sql);
 
		// // ******select group by
		List<String> str_groupby = Prasing_Test.test_select_groupby(sql);
 
		// //**************select order by
		List<String> str_orderby = Prasing_Test.test_select_orderby(sql);
 
	}
	public static void test_insert(String sql) throws JSQLParserException {
		// ****insert table
		String string_tablename = Prasing_Test.test_insert_table(sql);
 
		// ********* insert table column
		List<String> str_column = test_insert_column(sql);
 
		// ********Insert values ExpressionList強制轉換，參見InsertTest.java
		List<String> str_values = test_insert_values(sql);
	}
	public static void test_update(String sql) throws JSQLParserException {
 
		// *********update table name
		List<String> str_table = test_update_table(sql);
		// *********update column
		List<String> str_column = test_update_column(sql);
		// *********update values
		List<String> str_values = test_update_values(sql);
		// *******uodate where
		String str_where = test_update_where(sql);
 
	}
	
	// *********select body items內容
	public static List<String> test_select_items(String sql)
			throws JSQLParserException {
		CCJSqlParserManager parserManager = new CCJSqlParserManager();
		Select select = (Select) parserManager.parse(new StringReader(sql));
		PlainSelect plain = (PlainSelect) select.getSelectBody();
		List<SelectItem> selectitems = plain.getSelectItems();
		List<String> str_items = new ArrayList<String>();
		if (selectitems != null) {
			for (int i = 0; i < selectitems.size(); i++) {
				str_items.add(selectitems.get(i).toString());
			}
		}
		return str_items;
	}
 
	// **********select table
	// **********TablesNamesFinder:Find all used tables within an select
	public static List<String> test_select_table(String sql)
			throws JSQLParserException {
		Statement statement = (Statement) CCJSqlParserUtil.parse(sql);
		Select selectStatement = (Select) statement;
		TablesNamesFinder tablesNamesFinder = new TablesNamesFinder();
		List<String> tableList = tablesNamesFinder
				.getTableList(selectStatement);
		return tableList;
	}
 
	//******************* select join
	public static List<String> test_select_join(String sql)
			throws JSQLParserException {
		Statement statement = (Statement) CCJSqlParserUtil.parse(sql);
		Select selectStatement = (Select) statement;
		PlainSelect plain = (PlainSelect) selectStatement.getSelectBody();
		List<Join> joinList = plain.getJoins();
		List<String> tablewithjoin = new ArrayList<String>();
		if (joinList != null) {
			for (int i = 0; i < joinList.size(); i++) {
				tablewithjoin.add(joinList.get(i).toString());
				//注意 ， leftjoin rightjoin 等等的to string()區別
			}
		}
		return tablewithjoin;
	}
	
	// *******select where
	public static String test_select_where(String sql)
			throws JSQLParserException {
		CCJSqlParserManager parserManager = new CCJSqlParserManager();
		Select select = (Select) parserManager.parse(new StringReader(sql));
		PlainSelect plain = (PlainSelect) select.getSelectBody();
		Expression where_expression = plain.getWhere();
		String str = where_expression.toString();
		return str;
	}
 
	// ******select group by
	public static List<String> test_select_groupby(String sql)
			throws JSQLParserException {
		CCJSqlParserManager parserManager = new CCJSqlParserManager();
		Select select = (Select) parserManager.parse(new StringReader(sql));
		PlainSelect plain = (PlainSelect) select.getSelectBody();
		List<Expression> GroupByColumnReferences = plain
				.getGroupByColumnReferences();
		List<String> str_groupby = new ArrayList<String>();
		if (GroupByColumnReferences != null) {
			for (int i = 0; i < GroupByColumnReferences.size(); i++) {
				str_groupby.add(GroupByColumnReferences.get(i).toString());
			}
		}
		return str_groupby;
	}
 
	// **************select order by
	public static List<String> test_select_orderby(String sql)
			throws JSQLParserException {
		CCJSqlParserManager parserManager = new CCJSqlParserManager();
		Select select = (Select) parserManager.parse(new StringReader(sql));
		PlainSelect plain = (PlainSelect) select.getSelectBody();
		List<OrderByElement> OrderByElements = plain.getOrderByElements();
		List<String> str_orderby = new ArrayList<String>();
		if (OrderByElements != null) {
			for (int i = 0; i < OrderByElements.size(); i++) {
				str_orderby.add(OrderByElements.get(i).toString());
			}
		}
		return str_orderby;
	}
 
 
 
	// ****insert table
	public static String test_insert_table(String sql)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Insert insertStatement = (Insert) statement;
		String string_tablename = insertStatement.getTable().getName();
		return string_tablename;
	}
 
	// ********* insert table column
	public static List<String> test_insert_column(String sql)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Insert insertStatement = (Insert) statement;
		List<Column> table_column = insertStatement.getColumns();
		List<String> str_column = new ArrayList<String>();
		for (int i = 0; i < table_column.size(); i++) {
			str_column.add(table_column.get(i).toString());
		}
		return str_column;
	}
 
	// ********* Insert values ExpressionList
	public static List<String> test_insert_values(String sql)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Insert insertStatement = (Insert) statement;
		List<Expression> insert_values_expression = ((ExpressionList) insertStatement
				.getItemsList()).getExpressions();
		List<String> str_values = new ArrayList<String>();
		for (int i = 0; i < insert_values_expression.size(); i++) {
			str_values.add(insert_values_expression.get(i).toString());
		}
		return str_values;
	}
 
	// *********update table name
	public static List<String> test_update_table(String sql)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Update updateStatement = (Update) statement;
		List<Table> update_table = updateStatement.getTables();
		List<String> str_table = new ArrayList<String>();
		if (update_table != null) {
			for (int i = 0; i < update_table.size(); i++) {
				str_table.add(update_table.get(i).toString());
			}
		}
		return str_table;
 
	}
 
	// *********update column
	public static List<String> test_update_column(String sql)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Update updateStatement = (Update) statement;
		List<Column> update_column = updateStatement.getColumns();
		List<String> str_column = new ArrayList<String>();
		if (update_column != null) {
			for (int i = 0; i < update_column.size(); i++) {
				str_column.add(update_column.get(i).toString());
			}
		}
		return str_column;
 
	}
 
	// *********update values
	public static List<String> test_update_values(String sql)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Update updateStatement = (Update) statement;
		List<Expression> update_values = updateStatement.getExpressions();
		List<String> str_values = new ArrayList<String>();
		if (update_values != null) {
			for (int i = 0; i < update_values.size(); i++) {
				str_values.add(update_values.get(i).toString());
			}
		}
		return str_values;
 
	}
 
	// *******update where
	public static String test_update_where(String sql)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Update updateStatement = (Update) statement;
		Expression where_expression = updateStatement.getWhere();
		String str = where_expression.toString();
		return str;
	}
 
 
	public static void select_fromtxt() throws Exception {
		@SuppressWarnings("resource")
		BufferedReader reader = new BufferedReader(
				new FileReader(
						"D:\\java：eclipse\\workspace for javaSE\\JSql-test\\src\\test\\select_simple.txt"));
 
		List<String> statement_list = new ArrayList<String>();
		while (true) { // 輸出所有語句
			String line = reader.readLine();
			if (line == null) {
				break;
			} else
				statement_list.add(line);
		}
		for (int i = 0; i < 1; i++) {
			Prasing_Test.test_select(statement_list.get(i));
		}
	}
 
	public static void insert_fromtxt() throws Exception {
		@SuppressWarnings("resource")
		BufferedReader reader = new BufferedReader(
				new FileReader("文件位置"));
 
		List<String> statement_list = new ArrayList<String>();
		while (true) { // 輸出所有語句
			String line = reader.readLine();
			if (line == null) {
				break;
			} else
				statement_list.add(line);
		}
		for (int i = 0; i < 1; i++) {
			Prasing_Test.test_insert(statement_list.get(i));
		}
	}
 
	public static void update_fromtxt() throws Exception {
		@SuppressWarnings("resource")
		BufferedReader reader = new BufferedReader(
				new FileReader(
						"D:\\java：eclipse\\workspace for javaSE\\JSql-test\\src\\test\\update_simple.txt"));
 
		List<String> statement_list = new ArrayList<String>();
		while (true) { // 輸出所有語句
			String line = reader.readLine();
			if (line == null) {
				break;
			} else
				statement_list.add(line);
		}
		for (int i = 0; i < 1; i++) {
			Prasing_Test.test_update(statement_list.get(i));
		}
	}
 
}

building類函數

參數String sql以及修改過後的List<String>重新得到SQl語句

import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
 
import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.parser.CCJSqlParserManager;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.select.Join;
import net.sf.jsqlparser.statement.select.OrderByElement;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.statement.select.SelectExpressionItem;
import net.sf.jsqlparser.statement.select.SelectItem;
import net.sf.jsqlparser.statement.update.Update;
import net.sf.jsqlparser.util.TablesNamesFinder;
 
public class Building_test {
 
	// 由已知的List<String> 或 String 組裝成新的 sql 語句
 
	// 下面是   三個 sql語句 測試例子，select，insert，update
	public static void build_select(String sql) throws JSQLParserException {
		String change_sql = sql;
 
		// *********change body items
		List<String> str_items = new ArrayList<String>();
		str_items.add("school");
		str_items.add("teacher");
		change_sql = build_select_items(change_sql, str_items);
 
		// ********************change table only use " , " as join  such as (from table1,table2,table3)
//		List<String> str_table =new ArrayList<String>();
//		str_table.add("preson1");
//		str_table.add("preson2");
//		str_table.add("preson3");
//		change_sql = build_select_table(change_sql, str_table);
		
		// ********************change table with join  such as(from tb1 join tb2 left join tb3 right join tb4)
		List<String> str_table =new ArrayList<String>();
		str_table.add("preson1");
		str_table.add("preson2");
		str_table.add("preson3");
		str_table.add("preson4");
		List<String> str_tablewithjoin =new ArrayList<String>();
		str_tablewithjoin.add("preson1");
		str_tablewithjoin.add("LEFT JOIN preson2");
		str_tablewithjoin.add("RIGHT JOIN preson3");
		str_tablewithjoin.add("preson4");
		change_sql=Building_test.build_select_tablewithjoin(change_sql,str_tablewithjoin,str_table);
 
		// ******************select where
		String str_where = "name like 'abc'";
		change_sql = build_select_where(change_sql, str_where);
 
		// ******select group by
		List<String> str_groupby = new ArrayList<String>();
		str_groupby.add("studentname");
		str_groupby.add("studentid");
		change_sql = build_select_groupby(change_sql, str_groupby);
 
		// **************select order by
		List<String> str_orderby = new ArrayList<String>();
		str_orderby.add("name asc");// asc默認不顯示
		str_orderby.add("id desc");
		change_sql = build_select_orderby(change_sql, str_orderby);
 
		System.out.println("final:" + change_sql);
	}
 
	public static void build_insert(String sql) throws JSQLParserException {
		String change_sql = sql;
		// *******insert table
		String str_table = "teacher";
		change_sql = build_insert_table(change_sql, str_table);
 
		// ********* insert column
		List<String> str_column = new ArrayList<String>();
		str_column.add("school");
		str_column.add("city");
		change_sql = build_insert_column(change_sql, str_column);
 
		// ********* insert value
		List<String> str_value = new ArrayList<String>();
		str_value.add("'s'");
		str_value.add("6");
		change_sql = build_insert_values(change_sql, str_value);
		// System.out.println("final:" + change_sql);
 
	}
	public static void build_update(String sql) throws JSQLParserException {
		String change_sql = sql;
		// *********update table name
		List<String> str_table = new ArrayList<String>();
		str_table.add("yourtable");
		str_table.add("mytable");
		change_sql = build_update_table(change_sql, str_table);
		// *********update column
		List<String> str_column = new ArrayList<String>();
		str_column.add("col4");
		str_column.add("col5");
		str_column.add("col6");
		change_sql = build_update_column(change_sql, str_column);
 
		// *********update values
		List<String> str_values = new ArrayList<String>();
		str_values.add("'seemlike'");
		str_values.add("'cdc'");
		str_values.add("555");
		change_sql = build_update_values(change_sql, str_values);
 
		// *******update where
		String str_where = "id like '3'";
		change_sql = build_update_values(change_sql, str_where);	
	//	System.out.println("final:" + change_sql);
	}
 
	// *********change body items
	public static String build_select_items(String sql, List<String> str_items)
			throws JSQLParserException {
		CCJSqlParserManager parserManager = new CCJSqlParserManager();
		Select select = (Select) parserManager.parse(new StringReader(sql));
		// 改寫 selectitems 由 List<string> 類型轉化爲 selectitem 格式的函數
		select = Building_test.buildSelectFromStringExpressions(select,
				str_items);
		return select.toString();
 
	}
 
	// 原函數爲SelectUtils.buildSelectFromTableAndExpressions
	public static Select buildSelectFromStringExpressions(Select select,
			List<String> expr) throws JSQLParserException {
		SelectItem[] list = new SelectItem[expr.size()];
		PlainSelect plain = (PlainSelect) select.getSelectBody();
		plain.setSelectItems(null); // empty the existing selectitems
		for (int i = 0; i < expr.size(); i++) {
			list[i] = new SelectExpressionItem(
					CCJSqlParserUtil.parseExpression(expr.get(i)));
			plain.addSelectItems(list[i]);
		}
		select.setSelectBody(plain);
		return select;
	}
 
	// ********************change table only use " , " as join  such as (from table1,table2,table3)
	//**************notice*********parsing sql use function:test_select_table(sql) get List<Sting>
	public static String build_select_table(String sql, List<String> str_table)
			throws JSQLParserException {
		CCJSqlParserManager parserManager = new CCJSqlParserManager();
		Select select = (Select) parserManager.parse(new StringReader(sql));
		PlainSelect plain = (PlainSelect) select.getSelectBody();
		plain.setFromItem(null);
		plain.setJoins(null);
		List<Join>select_join =new ArrayList<Join>();
		
		if(str_table.size()==1){
			plain.setFromItem(new Table(str_table.get(0)));
		}
		for(int i=0;i<str_table.size()-1&&str_table.size()>=2;){      //no i++ 
			Join obj_join= new Join();
			if (i==0) plain.setFromItem(new Table(str_table.get(0)));
			obj_join.setSimple(true);    //假定所有表的連接均爲，——內連接
			i++;
			obj_join.setRightItem(new Table(str_table.get(i)));
			select_join.add(obj_join);
		}
		plain.setJoins(select_join);
	//	plain.setForUpdateTable(new Table(str_table));
		return select.toString();
	}
 
	// ********************change table with join  such as(from tb1 join tb2 left join tb3 right join tb4)
	//**************notice*********parsing use function:test_select_join(sql) get List<Sting>
	public static String build_select_tablewithjoin(String sql, List<String> str_tablewithjoin,List<String> str_table)
			throws JSQLParserException {
		CCJSqlParserManager parserManager = new CCJSqlParserManager();
		Select select = (Select) parserManager.parse(new StringReader(sql));
		PlainSelect plain = (PlainSelect) select.getSelectBody();
		
		plain.setFromItem(null);
		plain.setJoins(null);
		List<Join>select_join =new ArrayList<Join>();
		
		if(str_tablewithjoin.size()==1){
			plain.setFromItem(new Table(str_table.get(0)));
		}
		for(int i=0;i<str_tablewithjoin.size()-1&&str_tablewithjoin.size()>=2;){   //no i++ 
			Join obj_join= new Join();	
			if (i==0) plain.setFromItem(new Table(str_table.get(0)));
			i++;
			String judge=str_tablewithjoin.get(i).substring(0, 3);
			//這裏的判斷還不夠充分，繁瑣；；還有bug、和table name衝突
			if(judge.equals("LEF")) {obj_join.setLeft(true);}
			else if(judge.equals("RIG")) obj_join.setRight(true);
			else if(judge.equals("INN")) obj_join.setInner(true);
			else if(judge.equals("OUT")) obj_join.setOuter(true);
			else if(judge.equals("FUL")) obj_join.setFull(true);
	     //	else obj_join.setSimple(true);      //tb1 , tb2 == tb1 JOIN tb2
			
			obj_join.setRightItem(new Table(str_table.get(i)));
			select_join.add(obj_join);
		}
		plain.setJoins(select_join);
	//	plain.setForUpdateTable(new Table(str_table));
		return select.toString();
	}
	
	// ********************change where
	public static String build_select_where(String sql, String str_where)
			throws JSQLParserException {
		CCJSqlParserManager parserManager = new CCJSqlParserManager();
		Select select = (Select) parserManager.parse(new StringReader(sql));
		PlainSelect plain = (PlainSelect) select.getSelectBody();
		// parseCondExpression函數 不會被空格截斷
		Expression where_expression = (Expression) (CCJSqlParserUtil
				.parseCondExpression(str_where));
		plain.setWhere(where_expression);
		return select.toString();
	}
 
	// ********************change group by
	public static String build_select_groupby(String sql,
			List<String> str_groupby) throws JSQLParserException {
		CCJSqlParserManager parserManager = new CCJSqlParserManager();
		Select select = (Select) parserManager.parse(new StringReader(sql));
		PlainSelect plain = (PlainSelect) select.getSelectBody();
		List<Expression> GroupByColumnReferences = new ArrayList<Expression>();
		for (int i = 0; i < str_groupby.size(); i++) {
			GroupByColumnReferences.add(CCJSqlParserUtil
					.parseExpression(str_groupby.get(i)));
		}
		plain.setGroupByColumnReferences(GroupByColumnReferences);
		return select.toString();
	}
 
	// ********************change order by
	public static String build_select_orderby(String sql,
			List<String> str_orderby) throws JSQLParserException {
		CCJSqlParserManager parserManager = new CCJSqlParserManager();
		Select select = (Select) parserManager.parse(new StringReader(sql));
		PlainSelect plain = (PlainSelect) select.getSelectBody();
		List<OrderByElement> OrderByElements = new ArrayList<OrderByElement>();
		for (int i = 0; i < str_orderby.size(); i++) {
			OrderByElement obj_OrderbyElement = new OrderByElement(); // build
			// Element類實例放在循環內部，後面得到新的element實例
			String str = str_orderby.get(i);
			int k = str.length() - 3;
			char char_final = str.charAt(k);
			Expression orderby_expression = (Expression) (CCJSqlParserUtil
					.parseExpression(str));
			// 實例初始化，賦值expression以及boolean asc
			obj_OrderbyElement.setExpression(orderby_expression);
			if (char_final == 'a')
				obj_OrderbyElement.setAsc(true); // asc默認不顯示
			else
				obj_OrderbyElement.setAsc(false);
			// element加入到list中去
			OrderByElements.add(obj_OrderbyElement);
		}
		plain.setOrderByElements(OrderByElements);
		return select.toString();
	}
 
	// *******insert table
	public static String build_insert_table(String sql, String str_table)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Insert insertStatement = (Insert) statement;
		insertStatement.setTable(new Table(str_table));
		return insertStatement.toString();
 
	}
 
	// ********* insert column
	public static String build_insert_column(String sql, List<String> str_column)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Insert insertStatement = (Insert) statement;
		List<Column> insert_column = new ArrayList<Column>();
		for (int i = 0; i < str_column.size(); i++) {
			insert_column.add((Column) CCJSqlParserUtil
					.parseCondExpression(str_column.get(i)));
		}
		insertStatement.setColumns(insert_column);
		return insertStatement.toString();
 
	}
 
	// ********* insert values
	public static String build_insert_values(String sql, List<String> str_value)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Insert insertStatement = (Insert) statement;
		List<Expression> insert_values_expression = new ArrayList<Expression>();
		for (int i = 0; i < str_value.size(); i++) {
			insert_values_expression.add((Expression) CCJSqlParserUtil
					.parseExpression(str_value.get(i)));
		}
		// list to expressionlist to Itemlist
		insertStatement.setItemsList(new ExpressionList(
				insert_values_expression));
		return insertStatement.toString();
 
	}
 
	public static String build_update_table(String sql, List<String> str_table)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Update updateStatement = (Update) statement;
		List<Table> update_table = new ArrayList<Table>();
		for (int i = 0; i < str_table.size(); i++) {
			Table tabletest = new Table(); // string to Table
			tabletest.setName(str_table.get(i));
			update_table.add(tabletest);
		}
		updateStatement.setTables(update_table);
		return updateStatement.toString();
 
	}
	// *********update column
	public static String build_update_column(String sql, List<String> str_column)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Update updateStatement = (Update) statement;
		List<Column> update_column = new ArrayList<Column>();
		for (int i = 0; i < str_column.size(); i++) {
			update_column.add((Column) CCJSqlParserUtil
					.parseExpression(str_column.get(i)));
		}
		updateStatement.setColumns(update_column);
		return updateStatement.toString();
 
	}
	// *********update values
	public static String build_update_values(String sql, List<String> str_values)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Update updateStatement = (Update) statement;
		List<Expression> update_values = new ArrayList<Expression>();
		for (int i = 0; i < str_values.size(); i++) {
			update_values.add((Expression) CCJSqlParserUtil
					.parseExpression(str_values.get(i)));
		}
		updateStatement.setExpressions(update_values);
		return updateStatement.toString();
 
	}
	// *******update where
	public static String build_update_values(String sql, String str_where)
			throws JSQLParserException {
		Statement statement = CCJSqlParserUtil.parse(sql);
		Update updateStatement = (Update) statement;
		Expression where_expression = (Expression) (CCJSqlParserUtil
				.parseCondExpression(str_where));
		updateStatement.setWhere(where_expression);
		return updateStatement.toString();
 
	}
}

 

轉載自：作者：cuixuange 
來源：CSDN 
原文：https://blog.csdn.net/u014297722/article/details/53256533 
版權聲明：本文爲博主原創文章，轉載請附上博文鏈接！