类似hibernate实现sql增删改错

package utils;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;

public class SQLUtils {
/**
* 2014-05修改 增加对查询语句的缓存 增加对jdbcTemplt查询出的Map转换成Bean的方法
*/
private static Logger log = Logger.getLogger(SQLUtils.class);

private static Map cacheMap = new HashMap();
private static Map insertSqlCache = new HashMap();
private static Map updateSqlCache = new HashMap();
private static Map deleteSqlCache = new HashMap();
private static Map selectSqlCache = new HashMap();

/**
* 根据pojo类的class来构建select * from 的SQL语句
*
* @param pojoClass
* @return
*/
public static String buildSelectSql(Class pojoClass) {
List<FieldInfo> fieldInfoList = loadPojoSqlInfo(pojoClass);
String sql = buildSelectSql(pojoClass, fieldInfoList);
if (log.isDebugEnabled()) {
log.debug("select sql is:" + sql);
}
return sql;
}

/**
* 根据pojo类的class来构建insert的SQL语句
*
* @param pojoClass
* @return
*/
public static String buildInsertSql(Class pojoClass) {
List<FieldInfo> fieldInfoList = loadPojoSqlInfo(pojoClass);
String sql = buildInsertSql(pojoClass, fieldInfoList);
if (log.isDebugEnabled()) {
log.debug("insert sql is:" + sql);
}
return sql;
}

/**
* 根据pojo类的class构建根据pk来update的SQL语句
*
* @param pojoObject
* @return
*/
public static String buildUpdateSql(Class pojoClass) {
List<FieldInfo> fieldInfoList = loadPojoSqlInfo(pojoClass);
String sql = buildUpdateSqlByPK(pojoClass, fieldInfoList);
if (log.isDebugEnabled()) {
log.debug("update sql is:" + sql);
}
return sql;
}

/**
* 根据pojo类的Class和更新的条件字段来生成upate的SQL语句
*
* @param pojoClass
* @param columns
* @return
* @throws Exception
*/
public static String buildUpdateSqlByColumns(Class pojoClass,
String[] columns) throws Exception {
if (null != columns && columns.length > 0) {
List<FieldInfo> fieldInfoList = loadPojoSqlInfo(pojoClass);
String sql = buildUpdateSqlByColumns(pojoClass, fieldInfoList,
columns);
if (log.isDebugEnabled()) {
log.debug("update sql is:" + sql);
}
return sql;
} else {
if (log.isDebugEnabled()) {
log.debug("生成update sql error! 参数columns必须有值");
}
throw new Exception("参数columns必须有值！");
}
}

/**
* 根据pojo类的Class生成根据pk来delete的SQL语句
*
* @param pojoClass
* @return
*/
public static String buildDeleteSql(Class pojoClass) {
List<FieldInfo> fieldInfoList = loadPojoSqlInfo(pojoClass);
String sql = buildDeleteSqlByPK(pojoClass, fieldInfoList);
if (log.isDebugEnabled()) {
log.debug("delete sql is:" + sql);
}
return sql;
}

/**
* 根据pojo类的Class和更新的条件字段来生成delete的SQL语句
*
* @param pojoClass
* @param columns
* @return
* @throws Exception
*/
public static String buildDeleteSqlByColumns(Class pojoClass,
String[] columns) throws Exception {
if (null != columns && columns.length > 0) {
List<FieldInfo> fieldInfoList = loadPojoSqlInfo(pojoClass);
String sql = buildDeleteSqlByColumns(pojoClass, fieldInfoList,
columns);
if (log.isDebugEnabled()) {
log.debug("delete sql is:" + sql);
}
return sql;
} else {
if (log.isDebugEnabled()) {
log.debug("生成delete sql error! 参数columns必须有值");
}
throw new Exception("参数columns必须有值！");
}
}

/**
* 将SQL查询出来的map对象转成实体对象
*
* @param map
* @param pojoClass
* @return
* @throws Exception
*/
public static Object coverMapToBean(Map map, Class pojoClass)
throws Exception {
Object result = pojoClass.newInstance();

List<FieldInfo> list = loadPojoSqlInfo(pojoClass);
for (FieldInfo fieldInfo : list) {
String dbName = fieldInfo.getDbFieldName().toUpperCase();
String fieldName = fieldInfo.getPojoFieldName();
String setMethoName = "set"
+ fieldName.substring(0, 1).toUpperCase()
+ fieldName.substring(1);
if (map.get(dbName) != null) {
Method m = pojoClass.getMethod(setMethoName,
fieldInfo.getType());
m.invoke(result, map.get(dbName));
}
}
return result;
}

/**
* 加载读取pojo的注解信息
*
* @param pojoClass
* @return
*/
@SuppressWarnings("unchecked")
private static List<FieldInfo> loadPojoSqlInfo(Class pojoClass) {
List<FieldInfo> resultList = null;
if (null == cacheMap.get(pojoClass.getName())) {
resultList = new ArrayList<FieldInfo>();

java.lang.reflect.Field[] fields = pojoClass.getDeclaredFields();
for (java.lang.reflect.Field field : fields) {
FieldInfo fieldInfo = new FieldInfo();
fieldInfo.setPojoFieldName(field.getName());

if (field.isAnnotationPresent(Field.class)) {
String value = ((Field) field
.getAnnotation(Field.class)).value();// 得到配置的数据库字段名
if (StringUtils.isEmpty(value)) {// 没有设置数据库的字段名，则取pojo的字段名
fieldInfo.setDbFieldName(lowerStrToUnderline(field
.getName()));
} else {
fieldInfo.setDbFieldName(value);
}
} else {
fieldInfo.setDbFieldName(lowerStrToUnderline(field
.getName()));
}

if (field.isAnnotationPresent(PK.class)) {
fieldInfo.setIsPk(true);
}
if (field.isAnnotationPresent(NoInsert.class)) {
fieldInfo.setIsInsert(false);
}
if (field.isAnnotationPresent(NoUpdate.class)) {
fieldInfo.setIsUpdate(false);
}

fieldInfo.setType(field.getType());

resultList.add(fieldInfo);
}
cacheMap.put(pojoClass.getName(), resultList);
} else {
resultList = (List<FieldInfo>) cacheMap.get(pojoClass.getName());
}

return resultList;
}

/**
* 评价select语句
*
* @param pojoClass
* @param fieldInfoList
* @return
*/
private static String buildSelectSql(Class pojoClass,
List<FieldInfo> fieldInfoList) {
if (selectSqlCache.get(pojoClass.getName()) != null) {
return (String) selectSqlCache.get(pojoClass.getName());
}
return "select * from " + loadTableName(pojoClass);
}

/**
* 拼接insert的SQL
*
* @param pojoClass
* @param fieldInfoList
* @return
*/
@SuppressWarnings("unchecked")
private static String buildInsertSql(Class pojoClass,
List<FieldInfo> fieldInfoList) {
String result = null;
if (insertSqlCache.get(pojoClass.getName()) != null) {
result = (String) insertSqlCache.get(pojoClass.getName());
return result;
}

String tableName = loadTableName(pojoClass);

StringBuffer temp1 = new StringBuffer();
StringBuffer temp2 = new StringBuffer();
for (FieldInfo fieldInfo : fieldInfoList) {
if (fieldInfo.isInsert()) {
temp1.append(fieldInfo.getDbFieldName()).append(",");
temp2.append(":").append(fieldInfo.getPojoFieldName())
.append(",");
}
}
temp1.deleteCharAt(temp1.length() - 1);
temp2.deleteCharAt(temp2.length() - 1);

StringBuffer resultSql = new StringBuffer();
resultSql.append("insert into ");
resultSql.append(tableName);
resultSql.append("(");
resultSql.append(temp1);
resultSql.append(") values (");
resultSql.append(temp2);
resultSql.append(")");

result = resultSql.toString();
insertSqlCache.put(pojoClass.getName(), result);
return result;
}

/**
* 生成根据主键生成删除的SQL
*
* @param pojoClass
* @param fieldInfoList
* @return
*/
@SuppressWarnings("unchecked")
private static String buildDeleteSqlByPK(Class pojoClass,
List<FieldInfo> fieldInfoList) {
String result = null;
if (deleteSqlCache.get(pojoClass.getName() + "_pk") != null) {
result = (String) deleteSqlCache.get(pojoClass.getName());
return result;
}

StringBuffer resultSql = new StringBuffer();
resultSql.append(appendBaseDeleteSQL(pojoClass));

for (FieldInfo fieldInfo : fieldInfoList) {
if (fieldInfo.isPk()) {
resultSql.append(fieldInfo.getDbFieldName());
resultSql.append("=:").append(fieldInfo.getPojoFieldName())
.append(" and ");
}
}
resultSql.delete(resultSql.length() - 4, resultSql.length());
result = resultSql.toString();
deleteSqlCache.put(pojoClass.getName() + "_pk", result);

return result;
}

/**
* 拼接根据主键来update的SQL
*
* @param pojoClass
* @param fieldInfoList
* @return
*/
@SuppressWarnings("unchecked")
private static String buildUpdateSqlByPK(Class pojoClass,
List<FieldInfo> fieldInfoList) {
String result = null;
if (updateSqlCache.get(pojoClass.getName() + "_pk") != null) {
result = (String) updateSqlCache.get(pojoClass.getName() + "_pk");
return result;
}

StringBuffer resultSql = new StringBuffer();
resultSql.append(appendBaseUpdateSQL(pojoClass, fieldInfoList));

for (FieldInfo fieldInfo : fieldInfoList) {
if (fieldInfo.isPk()) {
resultSql.append(fieldInfo.getDbFieldName());
resultSql.append("=:").append(fieldInfo.getPojoFieldName())
.append(" and ");
}
}
resultSql.delete(resultSql.length() - 4, resultSql.length());
result = resultSql.toString();
updateSqlCache.put(pojoClass.getName() + "_pk", result);

return result;
}

/**
* 根据用户指定的更新条件(字段)来生成update的SQL
*
* @param pojoClass
* @param fieldInfoList
* @param columns
* @return
*/
private static String buildUpdateSqlByColumns(Class pojoClass,
List<FieldInfo> fieldInfoList, String[] columns) {
StringBuffer resultSql = new StringBuffer();
if (updateSqlCache.get(pojoClass.getName() + "_columns") != null) {
resultSql.append((String) updateSqlCache.get(pojoClass.getName()
+ "_columns"));
} else {
resultSql.append(appendBaseUpdateSQL(pojoClass, fieldInfoList));
}

for (String column : columns) {
for (FieldInfo fieldInfo : fieldInfoList) {
if (column.equals(fieldInfo.getPojoFieldName())) {
resultSql.append(fieldInfo.getDbFieldName());
resultSql.append("=:").append(column).append(" and ");
break;
}
}
}
resultSql.delete(resultSql.length() - 4, resultSql.length());
return resultSql.toString();
}

/**
* 拼接update语句的where之前的sql
*
* @param pojoClass
* @param fieldInfoList
* @param resultSql
*/
@SuppressWarnings("unchecked")
private static String appendBaseUpdateSQL(Class pojoClass,
List<FieldInfo> fieldInfoList) {
String result = null;
if (updateSqlCache.get(pojoClass.getName() + "_columns") != null) {
result = (String) updateSqlCache.get(pojoClass.getName()
+ "_columns");
} else {
StringBuffer resultSql = new StringBuffer();
String tableName = loadTableName(pojoClass);

resultSql.append("update ").append(tableName).append(" set ");
for (FieldInfo fieldInfo : fieldInfoList) {
if (fieldInfo.isUpdate() && !fieldInfo.isPk()) {
resultSql.append(fieldInfo.getDbFieldName());
resultSql.append("=:").append(fieldInfo.getPojoFieldName())
.append(",");
}
}
resultSql.deleteCharAt(resultSql.length() - 1);
resultSql.append(" where ");

result = resultSql.toString();
updateSqlCache.put(pojoClass.getName() + "_columns", result);
}
return result;
}

/**
* 根据用户指定的更新条件(字段)来生成delete的SQL
*
* @param pojoClass
* @param fieldInfoList
* @param columns
* @return
*/
private static String buildDeleteSqlByColumns(Class pojoClass,
List<FieldInfo> fieldInfoList, String[] columns) {
StringBuffer resultSql = new StringBuffer();
if (deleteSqlCache.get(pojoClass.getName() + "_columns") != null) {
resultSql.append((String) deleteSqlCache.get(pojoClass.getName()
+ "_columns"));
} else {
resultSql.append(appendBaseUpdateSQL(pojoClass, fieldInfoList));
}

for (String column : columns) {
for (FieldInfo fieldInfo : fieldInfoList) {
if (column.equals(fieldInfo.getPojoFieldName())) {
resultSql.append(fieldInfo.getDbFieldName());
resultSql.append("=:").append(column).append(" and ");
break;
}
}
}
resultSql.delete(resultSql.length() - 4, resultSql.length());
return resultSql.toString();
}

/**
* 拼接delete语句的where之前的sql
*
* @param pojoClass
* @param fieldInfoList
* @param resultSql
*/
@SuppressWarnings("unchecked")
private static String appendBaseDeleteSQL(Class pojoClass) {
if (deleteSqlCache.get(pojoClass.getName() + "_columns") != null) {
return (String) deleteSqlCache
.get(pojoClass.getName() + "_columns");
} else {
String result = "delete from " + loadTableName(pojoClass)
+ " where ";
deleteSqlCache.put(pojoClass.getName() + "_columns", result);
return result;
}
}

/**
* 通过类获取表名
*
* @param pojoClass
* @return
*/
@SuppressWarnings("unchecked")
private static String loadTableName(Class pojoClass) {
if (pojoClass.isAnnotationPresent(Table.class)) {
Table table = (Table) pojoClass.getAnnotation(Table.class);
return table.value();
} else {
return lowerStrToUnderline(pojoClass.getSimpleName());
}
}

/**
* 将大写字母转换成下划线加小写字母 例:userName--> user_name
*
* @param str
* @return
*/
private static String lowerStrToUnderline(String str) {
if (StringUtils.isEmpty(str)) {
return "";
}
StringBuilder sb = new StringBuilder(str);
char c;
int count = 0;
for (int i = 0; i < str.length(); i++) {
c = str.charAt(i);
if (c >= 'A' && c <= 'Z') {
sb.replace(i + count, i + count + 1, (c + "").toLowerCase());
sb.insert(i + count, "_");
count++;
}
}
return sb.toString();
}
}

package utils;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface PK {
}

package utils;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Table {
public String value();
}

package utils;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface NoUpdate {
}

package utils;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface NoInsert {
}

package utils;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Field {
//数据库字段名
public String value() default "";
}

package utils;

public class FieldInfo {
//java字段名
private String pojoFieldName;
//数据库字段名
private String dbFieldName;
//是否是主键
private boolean isPk = false;
//update时是否需要更新
private boolean isUpdate = true;
//insert时是否需要插入
private boolean isInsert = true;

private Class type;

public boolean isPk() {
return isPk;
}
public void setIsPk(boolean isPk) {
this.isPk = isPk;
}
public boolean isUpdate() {
return isUpdate;
}
public void setIsUpdate(boolean isUpdate) {
this.isUpdate = isUpdate;
}
public String getPojoFieldName() {
return pojoFieldName;
}
public void setPojoFieldName(String pojoFieldName) {
this.pojoFieldName = pojoFieldName;
}
public String getDbFieldName() {
return dbFieldName;
}
public void setDbFieldName(String dbFieldName) {
this.dbFieldName = dbFieldName;
}
public boolean isInsert() {
return isInsert;
}
public void setIsInsert(boolean isInsert) {
this.isInsert = isInsert;
}
public void setType(Class<?> type) {
// TODO Auto-generated method stub
this.type = type;
}
public Class getType() {
// TODO Auto-generated method stub
return this.type;
}
}

package utils;

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

import org.apache.commons.lang3.StringUtils;

public class Condition {
public static final String AND = " AND ";
public static final String OR = " OR ";
public static final char PREFIX_MATCH = 'P';
public static final char SUFFIX_MATCH = 'S';
public static final char GLOBAL_MATCH = 'G';
public static final char LIKE_MODE = 'L';
public static final char STANDARD_MODE = 0;

List<Integer> varTypesList = new ArrayList();
private String conditionClauseStr = "";
private String relateOperate = AND;
public Condition(ConditionDef def, Map valueMap) {
this(def, valueMap, AND);
}
public Condition(ConditionDef def, Map valueMap, String relateOperate) {
this.relateOperate = relateOperate;
String[] varNameArr = def.getConditionVarNames();
List<String> usedSubConditionClauseList = new ArrayList();

for (String varName : varNameArr) {
if (!StringUtils.isEmpty(valueMap.get(varName).toString())) {
usedSubConditionClauseList.add(def.getSubConditionClause(varName));
Object priValue =  valueMap.get(varName);
if (def.isExistClassTypeInfo(varName)) {
Class targetClass = def.getClassTypeInfo(varName);
Object newValue = null;
if (targetClass == java.sql.Date.class) {
newValue = java.sql.Date.valueOf((String)priValue);
valueMap.put(varName, newValue);
} else if (targetClass == java.sql.Timestamp.class) {
newValue = java.sql.Timestamp.valueOf((String)priValue);
valueMap.put(varName, newValue);
} else if (targetClass == java.sql.Time.class) {
newValue = java.sql.Time.valueOf((String)priValue);
valueMap.put(varName, newValue);
} else if (targetClass == java.util.List.class) {
List valueList=new ArrayList();
if (priValue.getClass().isArray()){
String[] valueArr=(String[])priValue;
for (String string : valueArr) {
valueList.add(string);
}
}else{
valueList.add(priValue);
}
valueMap.put(varName, valueList);
}
}
if (def.isExistMatchModeInfo(varName)) {
List<Character> matchModeList = def.getMatchModeInfo(varName);
if (matchModeList.size() == 1) {
if (matchModeList.get(0) == Condition.GLOBAL_MATCH) {
priValue = "%" + priValue + "%";
} else if (matchModeList.get(0) == Condition.PREFIX_MATCH) {
priValue = priValue + "%";
} else if (matchModeList.get(0) == Condition.SUFFIX_MATCH) {
priValue = "%" + priValue;
}
valueMap.put(varName , priValue);
} else {
for (char currMatchMode : matchModeList) {
if (currMatchMode == Condition.GLOBAL_MATCH) {
String newValue = "%" + priValue + "%";
valueMap.put(varName + "_globalMatch", newValue);
} else if (currMatchMode == Condition.PREFIX_MATCH) {
String newValue = priValue + "%";
valueMap.put(varName + "_prefixMatch", newValue);
} else if (currMatchMode == Condition.SUFFIX_MATCH) {
String newValue = "%" + priValue;
valueMap.put(varName + "_suffixMatch", newValue);
}
}
}
}
}
}
this.conditionClauseStr = StringUtils.join(usedSubConditionClauseList, relateOperate);

}
public String getConditionClause() {
return this.conditionClauseStr;
}
public String getConditionClauseWithWhere() {
return "".equals(conditionClauseStr)?"":" WHERE " + conditionClauseStr;
}
public String getConditionClauseWithStartRelateOperatorIfNeeded() {
if(conditionClauseStr.trim().equals("")) {
return "";
}else {
return this.relateOperate + " " + conditionClauseStr;
}

}
public String getConditionClauseWithRelateOperatorAtStart() {
return this.relateOperate + " " + conditionClauseStr;
}
public Integer[] getConditionVarTypes() {
return varTypesList.toArray(new Integer[]{});
}
}

package utils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ConditionDef {

private Map<String, String> paraNameAndSubConditionClauseMap = new LinkedHashMap();
private Map<String, Class> paraNameAndClassTypeMap = new HashMap();
private Map<String, List<Character>> paraNameAndLikeMatchInfoMap = new HashMap();
public ConditionDef(Object[][] defineArr) {
for (Object[] subDefine : defineArr) {

Pattern pattern = Pattern.compile(":([\\w\\d_]+)");
String currDefClause = (String) subDefine[0];
int currDefClauseLen = currDefClause.length();
Matcher matcher = pattern.matcher(currDefClause);
//System.out.println(currDefClause);
Set varNameSet = new HashSet();
int varNameCount = 0;

char clauseMode = Condition.STANDARD_MODE;
String oneVarName = null;
boolean isUsedSameMatchMode=true;
List<Character> matchModeList=new ArrayList();
while (matcher.find()) {
String varName = matcher.group(1);

oneVarName = varName;
int start = matcher.start();
int end = matcher.end();
char prefix = currDefClause.charAt(start - 1);

char suffix = end >= currDefClauseLen ? ' ' : currDefClause.charAt(end);
char subConditionMatchMode = Condition.STANDARD_MODE;
if (prefix == '%' && suffix == '%') {
clauseMode = subConditionMatchMode = Condition.GLOBAL_MATCH;
matchModeList.add(clauseMode);

} else if (prefix == '%') {
clauseMode = subConditionMatchMode = Condition.PREFIX_MATCH;
matchModeList.add(clauseMode);
} else if (suffix == '%') {
clauseMode = subConditionMatchMode = Condition.SUFFIX_MATCH;
matchModeList.add(clauseMode);
}

varNameSet.add(varName);
varNameCount++;
if(varNameCount>1&&matchModeList.size()>=2) {
int size=matchModeList.size();
if(!matchModeList.get(size-1).equals(matchModeList.get(size-2))) {
isUsedSameMatchMode=false;
}
}
}

if (varNameSet.size() != 1) {
throw new RuntimeException("One sub condition clause must only have one var name ! clause :"
+ currDefClause);
}
if (oneVarName == null) {
throw new RuntimeException("Sub condition is not have any var name ! clause :" + currDefClause);
}

if (subDefine.length > 1) {

paraNameAndClassTypeMap.put(oneVarName, (Class) subDefine[1]);
//System.out.println("save var type : " + oneVarName + "," + ((Class) subDefine[1]).getSimpleName());
}
if (clauseMode != Condition.STANDARD_MODE) {
if (isUsedSameMatchMode&&varNameCount==matchModeList.size()) {

paraNameAndLikeMatchInfoMap.put(oneVarName, matchModeList.subList(0,1));
} else {
currDefClause=currDefClause.replaceAll("%:"+oneVarName+"%", ":"+oneVarName+"_globalMatch");
currDefClause=currDefClause.replaceAll("%:"+oneVarName, ":"+oneVarName+"_suffixMatch");
currDefClause=currDefClause.replaceAll(":"+oneVarName+"%", ":"+oneVarName+"_prefixMatch");
paraNameAndLikeMatchInfoMap.put(oneVarName, matchModeList);
}
currDefClause = currDefClause.replaceAll("'\\%", "");
currDefClause = currDefClause.replaceAll("\\%'", "");
currDefClause = currDefClause.replaceAll("\\%", "");
currDefClause = currDefClause.replaceAll("'", "");
//System.out.println("processed clause : " + currDefClause);
}
String tempClause=currDefClause.toUpperCase();
if(tempClause.indexOf("AND")!=-1||tempClause.indexOf("OR")!=-1) {
currDefClause="("+currDefClause+")";
}
paraNameAndSubConditionClauseMap.put(oneVarName, currDefClause);

}

}

public String[] getConditionVarNames() {
// TODO Auto-generated method stub
return paraNameAndSubConditionClauseMap.keySet().toArray(new String[paraNameAndSubConditionClauseMap.keySet().size()]);
}
public String getSubConditionClause(String varName) {
// TODO Auto-generated method stub
return paraNameAndSubConditionClauseMap.get(varName);
}
public boolean isExistClassTypeInfo(String varName) {
// TODO Auto-generated method stub
return paraNameAndClassTypeMap.containsKey(varName);
}
public Class getClassTypeInfo(String varName) {
// TODO Auto-generated method stub
return paraNameAndClassTypeMap.get(varName);
}
public boolean isExistMatchModeInfo(String varName) {
// TODO Auto-generated method stub
return paraNameAndLikeMatchInfoMap.containsKey(varName);
}
public List<Character> getMatchModeInfo(String varName) {
// TODO Auto-generated method stub
return paraNameAndLikeMatchInfoMap.get(varName);
}
}