增加人大金仓数据库支持

o2server/x_base_core_project/src/main/java/com/x/base/core/container/factory/SlicePropertiesBuilder.java

@@ -22,6 +22,7 @@ public class SlicePropertiesBuilder {
 	public static String driver_dm = "dm.jdbc.driver.DmDriver";
 	public static String driver_sqlserver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
 	public static String driver_gbase = "com.gbasedbt.jdbc.IfxDriver";
+	public static String driver_kingbase = "com.kingbase.Driver";
 	/** 避免db2在aix版本和lwl版本字段长度不一致的问题 */
 	public static String dictionary_db2 = "db2(createPrimaryKeys=false,characterColumnSize=255,maxColumnNameLength=128,maxIndexNameLength=128,maxConstraintNameLength=128)";
 	public static String dictionary_oracle = "oracle(maxTableNameLength=128,maxColumnNameLength=128,maxIndexNameLength=128,maxConstraintNameLength=128,maxEmbeddedClobSize=-1,maxEmbeddedBlobSize=-1)";
@@ -32,6 +33,8 @@ public class SlicePropertiesBuilder {
 	public static String dictionary_dm = "com.x.base.core.openjpa.jdbc.sql.DMDictionary";
 	public static String dictionary_sqlserver = "sqlserver(schemaCase=preserve)";
 	public static String dictionary_gbase = "com.x.base.core.openjpa.jdbc.sql.GBaseDictionary";
+	public static String dictionary_kingbase = "com.x.base.core.openjpa.jdbc.sql.KingbaseDictionary";
+//	public static String dictionary_kingbase = "org.apache.openjpa.jdbc.sql.KingbaseDictionary";
 
 	public static String validationQuery_db2 = "select 1 from sysibm.sysdummy1";
 	public static String validationQuery_oracle = "select 1 from dual";
@@ -42,6 +45,7 @@ public class SlicePropertiesBuilder {
 	public static String validationQuery_dm = "select getdate()";
 	public static String validationQuery_sqlserver = "select 1";
 	public static String validationQuery_gbase = "select 1";
+	public static String validationQuery_kingbase = "select 1";
 
 	public static Map<String, String> getPropertiesDBCP(List<DataMapping> list) throws Exception {
 		try {
@@ -54,16 +58,13 @@ public class SlicePropertiesBuilder {
 			/**
 			 * 如果是DB2 添加 Schema,mysql 不需要Schema 如果用了Schema H2数据库就会报错说没有Schema
 			 */
-			if (StringUtils.equals(determineDBDictionary(list.get(0)), dictionary_db2)) {
-				properties.put("openjpa.jdbc.Schema", JpaObject.default_schema);
-			}
-			if (StringUtils.equals(determineDBDictionary(list.get(0)), dictionary_informix)) {
-				properties.put("openjpa.jdbc.Schema", JpaObject.default_schema);
-			}
-			if (StringUtils.equals(determineDBDictionary(list.get(0)), dictionary_gbase)) {
-				properties.put("openjpa.jdbc.Schema", JpaObject.default_schema);
-			}
-			if (StringUtils.equals(determineDBDictionary(list.get(0)), dictionary_dm)) {
+
+			if ((StringUtils.equals(determineDBDictionary(list.get(0)), dictionary_db2))
+					|| (StringUtils.equals(determineDBDictionary(list.get(0)), dictionary_informix))
+					|| (StringUtils.equals(determineDBDictionary(list.get(0)), dictionary_gbase))
+					|| (StringUtils.equals(determineDBDictionary(list.get(0)), dictionary_dm))
+					|| (StringUtils.equals(determineDBDictionary(list.get(0)), dictionary_dm))
+					|| (StringUtils.equals(determineDBDictionary(list.get(0)), dictionary_kingbase))) {
 				properties.put("openjpa.jdbc.Schema", JpaObject.default_schema);
 			}
 			properties.put("openjpa.slice.Lenient", "false");
@@ -179,6 +180,10 @@ public class SlicePropertiesBuilder {
 				String url = dataMapping.getUrl();
 				str += ",validationQuery=" + validationQuery_sqlserver + ", driverClassName=" + driver_sqlserver
 						+ ", url=" + url;
+			} else if (StringUtils.equals(determineDBDictionary(dataMapping), dictionary_kingbase)) {
+				String url = dataMapping.getUrl();
+				str += ",validationQuery=" + validationQuery_kingbase + ", driverClassName=" + driver_kingbase
+						+ ", url=" + url;
 			}
 			return str;
 		} catch (Exception e) {
@@ -225,6 +230,10 @@ public class SlicePropertiesBuilder {
 				String url = dataMapping.getUrl();
 				str += ", validationQuery=" + validationQuery_sqlserver + ", driverClassName=" + driver_sqlserver
 						+ ", url=" + url;
+			} else if (StringUtils.equals(determineDBDictionary(dataMapping), dictionary_kingbase)) {
+				String url = dataMapping.getUrl();
+				str += ", validationQuery=" + validationQuery_kingbase + ", driverClassName=" + driver_kingbase
+						+ ", url=" + url;
 			}
 			return str;
 		} catch (Exception e) {
@@ -253,6 +262,8 @@ public class SlicePropertiesBuilder {
 				return driver_dm;
 			} else if (StringUtils.equals(determineDBDictionary(dataMapping), dictionary_sqlserver)) {
 				return driver_sqlserver;
+			} else if (StringUtils.equals(determineDBDictionary(dataMapping), dictionary_kingbase)) {
+				return driver_kingbase;
 			}
 			throw new Exception("database jdbc driver miss match:" + dataMapping.getUrl());
 		} catch (Exception e) {
@@ -292,6 +303,8 @@ public class SlicePropertiesBuilder {
 				return dictionary_dm;
 			} else if (StringUtils.containsIgnoreCase(dataMapping.getUrl(), "jdbc:sqlserver:")) {
 				return dictionary_sqlserver;
+			} else if (StringUtils.containsIgnoreCase(dataMapping.getUrl(), "jdbc:kingbase:")) {
+				return dictionary_kingbase;
 			}
 			throw new Exception("database jdbc driver miss match:" + dataMapping.getUrl());
 		} catch (Exception e) {

o2server/x_base_core_project/src/main/java/com/x/base/core/openjpa/jdbc/sql/KingbaseDictionary.java

+package com.x.base.core.openjpa.jdbc.sql;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.SQLException;
+
+import org.apache.openjpa.jdbc.sql.DBDictionary;
+import org.apache.openjpa.lib.util.Localizer;
+
+public class KingbaseDictionary extends DBDictionary {
+
+	public static final String VENDOR_DAMENG = "Kingbase";
+	private static final Localizer _loc = Localizer.forPackage(DMDictionary.class);
+
+	public KingbaseDictionary() {
+		this.platform = "Kingbase";
+		supportsDeferredConstraints = false;
+	}
+
+	public void connectedConfiguration(Connection conn) throws SQLException {
+		super.connectedConfiguration(conn);
+		boolean requiresWarnings = true;
+		DatabaseMetaData meta = conn.getMetaData();
+		String driverName = meta.getDriverName();
+		String url = meta.getURL();
+		if (this.driverVendor == null) {
+			if ((driverName != null) && (driverName.equalsIgnoreCase("com.kingbase.Driver"))) {
+				this.driverVendor = "KingbaseJdbcDriver";
+				if ((url != null) && (url.startsWith("jdbc:kingbase://"))) {
+					requiresWarnings = false;
+				}
+			} else {
+				this.driverVendor = "other";
+			}
+		}
+		if (("KingbaseJdbcDriver".equalsIgnoreCase(this.driverVendor)) && (requiresWarnings)) {
+			this.log.warn(_loc.get("kingbase Jdbc connection", url));
+		}
+	}
+
+}

o2server/x_base_core_project/src/main/java/com/x/base/core/openjpa/jdbc/sql/KingbaseDictionary2.java

+package com.x.base.core.openjpa.jdbc.sql;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Set;
+
+import org.apache.openjpa.jdbc.sql.DBDictionary;
+import org.apache.openjpa.jdbc.sql.SQLBuffer;
+import org.apache.openjpa.lib.log.Log;
+import org.apache.openjpa.lib.util.Localizer;
+
+public class KingbaseDictionary2 extends DBDictionary {
+	public static final String VENDOR_DAMENG = "kingbase";
+	private static final Localizer _loc = Localizer.forPackage(KingbaseDictionary2.class);
+	private String schemaCase = "preserve";
+	public boolean uniqueIdentifierAsVarbinary = true;
+
+	public KingbaseDictionary2() {
+		this.platform = "kingbase";
+		this.validationSQL = "SELECT GETDATE()";
+		this.supportsAutoAssign = true;
+		this.autoAssignClause = "IDENTITY";
+		this.lastGeneratedKeyQuery = "SELECT @@IDENTITY";
+		this.nextSequenceQuery = "SELECT {0}.NEXTVAL";
+		this.integerTypeName = "INT";
+		this.substringFunctionName = "SUBSTR";
+
+		this.reservedWordSet.addAll(Arrays.asList(new String[] { "ABORT", "ABSOLUTE", "ABSTRACT", "ACROSS", "ACTION",
+				"ADD", "AUDIT", "ADMIN", "AFTER", "ALL", "ALLOW_DATETIME", "ALLOW_IP", "ALTER", "ANALYZE", "AND", "ANY",
+				"ARCHIVEDIR", "ARCHIVELOG", "ARCHIVESTYLE", "ARRAY", "ARRAYLEN", "AS", "ASC", "ASSIGN", "AT", "ATTACH",
+				"AUTHORIZATION", "AUTO", "AUTOEXTEND", "AVG", "BACKUP", "BACKUPDIR", "BACKUPINFO", "BAKFILE", "BASE",
+				"BEFORE", "BEGIN", "BETWEEN", "BIGDATEDIFF", "BIGINT", "BINARY", "BIT", "BITMAP", "BLOB", "BLOCK",
+				"BOOL", "BOOLEAN", "BOTH", "BOUNDARY", "BRANCH", "BREAK", "BSTRING", "BTREE", "BY", "BYTE", "CACHE",
+				"CALL", "CASCADE", "CASCADED", "CASE", "CAST", "CATALOG", "CATCH", "CHAIN", "CHAR", "CHARACTER",
+				"CHECK", "CIPHER", "CLASS", "CLOB", "CLOSE", "CLUSTER", "CLUSTERBTR", "COLUMN", "COMMENT", "COMMIT",
+				"COMMITTED", "COMMITWORK", "COMPILE", "COMPRESS", "COMPRESSED", "CONNECT", "CONNECT_BY_IS_CYCLE",
+				"CONNECT_BY_IS_LEAF", "CONNECT_BY_ROOT", "CONNECT_IDLE_TIME", "CONST", "CONSTANT", "CONSER_OP",
+				"CONSTRAINT", "CONTAINS", "CONTEXT", "CONTINUE", "CONVERT", "COUNT", "CPU_REF_CALL", "CPU_REF_SESSION",
+				"CREATE", "CROSS", "CRYPTO", "CTLFILE", "CUBE", "CURRENT", "CURSOR", "CYCLE", "DANGLING", "DATABASE",
+				"DATAFILE", "DATE", "DATEADD", "DATEDIFF", "DATEPART", "DATETIME", "DAY", "DBFILE", "DEBUG", "DEC",
+				"DECIMAL", "DECLARE", "DECODE", "DEFAULT", "DEFERRABLE", "DELETE", "DELETING", "DEREF", "DESC",
+				"DETACH", "DISABLE", "DISCONNECT", "DISKSPACE", "DISTINCT", "DISTRIBUTED", "DO", "DOUBLE", "DOWN",
+				"DROP", "EACH", "ELSE", "ELSEIF", "ENABLE", "ENCRYPT", "ENCRYPTION", "END", "EQU", "ERROR", "ESCAPE",
+				"EVENTINFO", "EXCEPT", "EXCEPTION", "EXCHANGE", "EXCLUSIVE", "EXECUTE", "EXISTS", "EXIT", "EXPLAIN",
+				"EXTERN", "EXTERNAL", "EXTERNALLY", "EXTRACT", "FAILED_LOGIN_ATTEMPS", "FALSE", "FETCH", "FILEGROUP",
+				"FILLFACTOR", "FINALLY", "FIRST", "FLOAT", "FOR", "FORCE", "FOREIGN", "FREQUENCE", "FROM", "FULL",
+				"FUNCTION", "FOLLOWING", "GET", "GLOBAL", "GOTO", "GRANT", "GROUP GROUPING", "HASH", "HAVING",
+				"HEXTORAW", "HOUR", "IDENTIFIED", "IDENTITY", "IDENTITY_INSERT", "IF", "IMAGE", "IMMEDIATE", "IN",
+				"INCREASE", "INCREMENT", "INDEX", "INITIAL", "INITIALLY", "INNER", "INNERID", "INSERT", "INSERTING",
+				"INSTEAD", "INT", "INTEGER", "INTENT", "INTERNAL", "INTERSECT", "INTERVAL", "INTO", "IS", "ISOLATION",
+				"JAVA", "JOIN", "KEY", "LABEL", "LAST", "LEAD", "LEFT", "LESS", "LEVEL", "LEXER", "LIKE", "LIMIT",
+				"LINK", "LIST", "LOB", "LOCAL", "LOCK", "LOG", "LOGFILE", "LOGIN", "LOGOUT", "LONG", "LONGVARBINARY",
+				"LONGVARCHAR", "LOOP", "LP_OP", "LT_BINTEGER", "LT_BIGINTEGER", "LT_BITSTRING", "LT_DECIMAL",
+				"LT_GLOBAL_VAR", "LT_IDENTIFIER", "LT_INTEGER", "LP_REAL", "LT_STRING", "MANUAL", "MAP", "MATCH",
+				"MATCHED", "MAX", "MAXSIZE", "MAXVALUE", "MEMBER", "MEN_SPACE", "MERGE", "MIN", "MINEXTENTS", "MINUS",
+				"MINUTE", "MINVALUE", "MODE", "MODIFY", "MONEY", "MONTH", "MOUNT", "NATURAL", "NEW", "NEXT", "NO",
+				"NOARCHIVELOG", "NOAUDIT", "NOBRANCH", "NOCACHE", "NOCYCLE", "NOMAXVALUE", "NOMINVALUE", "NONE",
+				"NOORDER", "NORMAL", "NOSALT", "NOT", "NOT_ALLOW_DATETIME", "NOT_ALLOW_IP", "NOWAIT", "NULL", "",
+				"NUMBER", "NUMERIC", "OBJECT", "OF", "OFF", "OFFLINE", "OFFSET", "OLD", "ON", "ONCE", "ONLINE", "ONLY",
+				"OP_SHIFT_LERT", "OP_SHIFT_RIGHT", " OPEN", "OPTION", "OR", "ORDER", "OUT", "OUTER", "OVER ",
+				"OVERLAPS", "OVERRIDE", "PACKAGE", "PACKAGE_BODY", "PAGE", "PARTIAL", "PARTITION", "PARTITIONS",
+				"PASSWORD_GRACE_TIME", "PASSWORD_LIFE_TIME", "PASSWORD_LOCK_TIME", "PASSWORD_POLICY",
+				"PASSWORD_REUSE_MAX", "PASSWORD_REUSE_TIME", "PENDANT", "PERCENT", "PRECEDING", "PRECISION", "PRESERVE",
+				"PRIMARY", "PRINT", "PRIOR", "PRIVATE", "PRIVILEGES", "PROCEDURE", "PROTECTED", "PT_FOUND", "PT_ISOPEN",
+				"PT_NOFOUND", "PT_ROWCOUNT", "PT_ROWTYPE", "PT_TYPE", "PUBLIC", "PUT", "RAISE", "RANGE", "RAWTOHEX",
+				"READ", "READ_PER_CALL", "READ_PER_SESSION", "READONLY", "REAL", "REBUILD", "RECORD", "REF",
+				"REFERENCES", "REFERENCING", "RELATED", "RELATIVE", "RENAME", "REPEAT", "REPEATABLE", "REPLACE",
+				"REPLICATE", "RESIZE", "RESTORE", "RESTRICT", "RETURN", "RETURNING", "REVERSE", "REVOKE", "RIGHT",
+				"ROLE", "ROLLBACK", "ROLLFILE", "ROLLUP", "ROOT", "ROW", "ROWCOUNT", "ROWID", "ROWNUM", "ROWS", "RULE",
+				"SALT", "SAVEPOINT", "SBYTE", "SCHEMA", "SCOPE", "SEALED", "SECTION", "SECOND", "SELECT", "SELSTAR",
+				"SEQUENCE", "SERERR", "SERIALIZABLE", "SERVER", "SESSION_PER_USER", "SET", "SETS", "SHARE", "SHORT",
+				"SHUTDOWN", "SIBLINGS", "SIZE", "SIZEOF", "SMALLINT", "SNAPSHOT", "SOME", "SOUND", "SPLIT", "SQL",
+				"STANDBY", "START_WITH", "STARTUP", "STATEMENT", "STATIC", "STAT", "STDDEV", "STORAGE", "STORE",
+				"STRING", "STRUCT", "STYLE", "SUBSTRING", "SUCCESSFUL", "SUM", "SUSPEND", "SWITCH", "SYNC", "SYNONYM",
+				"SYS_CONNECT_BY_PATH", "TABLE", "TABLESPACE", "TEMPORARY", "TEXT", "THAN", "THEN", "THROW", "TIES",
+				"TIME", "TIMER", "TIMES", "TIMESTAMP", "TIMESTAMPADD", "TIMESTAMPDIFF", "TINYINT", "TO",
+				"TOO_MANY_ROWS", "TOP", "TRAIL", "TRANSACTION", "TRANSACTIONAL", "TRIGGER", "TRIGGERS", "TRIM", "TRUE",
+				"TRUNCATE", "TRUNCSIZE", "TRY", "TYPE", "TYPE_BODY", "TYPEOF", "UINT", "ULONG", "UNBOUNDED",
+				"UNCOMMITTED", "UNDER", "UNION", "UNIQUE", "UNLIMITED", "UNSAFE", "UNTIL", "UP", "UPDATE", "UPDATING",
+				"USER", "USHORT", "USING", "VALUE", "VALUES", "VARBINARY", "VARCHAR", "VARCHAR2", "VARIANCE", "VARYING",
+				"VERIFY", "VERTICAL", "VIEW", "VIRTUAL", "VOID", "VOLATILE", "VSIZE", "WEEK", "WHEN", "WHENEVER",
+				"WHERE", "WHILE", "WITH", "WORK", "WRAPPED", "WRITE", "YEAR", "ZONE" }));
+		this.systemSchemaSet.addAll(Arrays.asList(new String[] { "CTISYS", "SYS", "SYSDBA", "SYSSSO", "SYSAUDITOR" }));
+		this.fixedSizeTypeNameSet
+				.addAll(Arrays.asList(new String[] { "IMAGE", "TEXT", "DATETIME", "LONGVARBINARY", "LONGVARCHAR" }));
+
+		this.supportsDeferredConstraints = true;
+		this.supportsSelectEndIndex = true;
+	}
+
+	protected void appendSelectRange(SQLBuffer buf, long start, long end, boolean subselect) {
+		buf.append(" LIMIT ").appendValue(start).append(", ").appendValue(end - start);
+	}
+
+	public void connectedConfiguration(Connection conn) throws SQLException {
+		super.connectedConfiguration(conn);
+		boolean requiresWarnings = true;
+		DatabaseMetaData meta = conn.getMetaData();
+		String driverName = meta.getDriverName();
+		String url = meta.getURL();
+		if (this.driverVendor == null) {
+			if ((driverName != null) && (driverName.equalsIgnoreCase("com.kingbase.Driver"))) {
+				this.driverVendor = "KingbaseJdbcDriver";
+				if ((url != null) && (url.startsWith("jdbc:kingbase://"))) {
+					requiresWarnings = false;
+				}
+			} else {
+				this.driverVendor = "other";
+			}
+		}
+		if (("KingbaseJdbcDriver".equalsIgnoreCase(this.driverVendor)) && (requiresWarnings)) {
+			this.log.warn(_loc.get("Kingbase Jdbc connection", url));
+		}
+	}
+
+	public Date getDate(ResultSet rs, int column) throws SQLException {
+		return rs.getDate(column);
+	}
+}

o2server/x_base_core_project/src/main/java/com/x/base/core/openjpa/jdbc/sql/KingbaseDictionary3.java

+package com.x.base.core.openjpa.jdbc.sql;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Date;
+
+import org.apache.openjpa.jdbc.kernel.exps.FilterValue;
+import org.apache.openjpa.jdbc.schema.Column;
+import org.apache.openjpa.jdbc.schema.Sequence;
+import org.apache.openjpa.jdbc.schema.Table;
+import org.apache.openjpa.jdbc.sql.DBDictionary;
+import org.apache.openjpa.jdbc.sql.SQLBuffer;
+import org.apache.openjpa.lib.jdbc.DelegatingConnection;
+import org.apache.openjpa.lib.jdbc.DelegatingPreparedStatement;
+
+public class KingbaseDictionary3 extends DBDictionary {
+	public String allSequencesSQL = "select SYS_NAMESPACE.NSPNAME as SEQUENCE_SCHEMA, SYS_CLASS.RELNAME as SEQUENCE_NAME from SYS_NAMESPACE,SYS_CLASS where SYS_NAMESPACE.OID=SYS_CLASS.RELNAMESPACE and SYS_CLASS.RELKIND='S'";
+	public String namedSequencesFromAllSchemasSQL = "select SYS_NAMESPACE.NSPNAME as SEQUENCE_SCHEMA, SYS_CLASS.RELNAME as SEQUENCE_NAME from SYS_NAMESPACE,SYS_CLASS where  SYS_NAMESPACE.OID=SYS_CLASS.RELNAMESPACE and SYS_CLASS.RELKIND='S' AND SYS_CLASS.RELNAME = ?";
+	public String allSequencesFromOneSchemaSQL = "select SYS_NAMESPACE.NSPNAME as SEQUENCE_SCHEMA, SYS_CLASS.RELNAME as SEQUENCE_NAME from SYS_NAMESPACE,SYS_CLASS where SYS_NAMESPACE.OID=SYS_CLASS.RELNAMESPACE and SYS_CLASS.RELKIND='S' AND SYS_NAMESPACE.NSPNAME = ?";
+	public String namedSequenceFromOneSchemaSQL = "select SYS_NAMESPACE.NSPNAME as SEQUENCE_SCHEMA, SYS_CLASS.RELNAME as SEQUENCE_NAME from SYS_NAMESPACE,SYS_CLASS where  SYS_NAMESPACE.OID=SYS_CLASS.RELNAMESPACE and SYS_CLASS.RELKIND='S' AND SYS_CLASS.RELNAME = ? AND SYS_NAMESPACE.NSPNAME = ?";
+
+	public KingbaseDictionary3() {
+		this.platform = "KingbaseES";
+		this.validationSQL = "SELECT NOW()";
+		this.supportsSelectStartIndex = true;
+		this.supportsSelectEndIndex = true;
+		this.supportsLockingWithDistinctClause = false;
+		this.maxTableNameLength = 63;
+		this.maxColumnNameLength = 63;
+		this.maxIndexNameLength = 63;
+		this.maxConstraintNameLength = 63;
+		this.maxAutoAssignNameLength = 63;
+		this.lastGeneratedKeyQuery = "SELECT CURRVAL(''{2}'')";
+		this.supportsAutoAssign = true;
+		this.autoAssignTypeName = "INT IDENTITY";
+		this.nextSequenceQuery = "SELECT NEXTVAL(''{0}'')";
+		this.binaryTypeName = "BYTEA";
+		this.longVarbinaryTypeName = "BYTEA";
+		this.varbinaryTypeName = "BYTEA";
+		this.longVarcharTypeName = "TEXT";
+		this.charTypeName = "CHAR{0}";
+		this.varcharTypeName = "VARCHAR{0}";
+		this.systemSchemaSet.addAll(Arrays.asList(new String[] { "INFORMATION_SCHEMA", "SYS_CATALOG" }));
+		this.fixedSizeTypeNameSet.addAll(Arrays.asList(new String[] { "TEXT", "XML", "INTERVAL YEAR", "INTERVAL MONTH",
+				"INTERVAL DAY", "INTERVAL HOUR", "INTERVAL MINUTE", "INTERVAL SECOND", " INTERVAL YEAR TO MONTH",
+				"INTERVAL DAY TO SECOND", "BIT VARYING", "BYTEA", "BOOLEAN" }));
+		this.reservedWordSet.addAll(Arrays.asList(new String[] { "ABORT", "ABSOLUTE", "ACCESS", "ACTION", "ADD",
+				"ADMIN", "AFTER", "AGGREGATE", "ALL", "ALSO", "ALTER", "ANALYSE", "ANALYZE", "AND", "ANY", "ARRAY",
+				"AS", "ASC", "ASSERTION", "ASSIGNMENT", "ASYMMETRIC", "AT", "AUTHID", "AUTHORIZATION", "BACKWARD",
+				"BEFORE", "BEGIN", "BETWEEN", "BIGINT", "BINARY", "BIT", "BODY", "BOOLEAN", "BOTH", "BY", "CACHE",
+				"CALL", "CALLED", "CASCADE", "CASCADED", "CASE", "CAST", "CHAIN", "CHAR", "CHARACTER",
+				"CHARACTERISTICS", "CHECK", "CHECKALLOCATE", "CHECKCATALOG", "CHECKDB", "CHECKINDEX", "CHECKPOINT",
+				"CHECKTABLE", "CHECKTABLESPACE", "CLASS", "CLOSE", "CLUSTER", "COALESCE", "COLLATE", "COLUMN",
+				"COMMENT", "COMMIT", "COMMITTED", "CONCURRENTLY", "CONNECTION", "CONSTANT", "CONSTRAINT", "CONSTRAINTS",
+				"CONVERSION", "CONVERT", "COPY", "CREATE", "CREATEDB", "CREATEROLE", "CREATEUSER", "CROSS", "CSV",
+				"CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR", "CYCLE",
+				"DATABASE", "DATAFILE", "DATEADD", "DATEDIFF", "DATEPART", "DAY", "DBCC", "DEALLOCATE", "DEC",
+				"DECIMAL", "DECLARE", "DEFAULT", "DEFAULTS", "DEFERRABLE", "DEFERRED", "DEFINER", "DELETE", "DELIMITER",
+				"DELIMITERS", "DESC", "DISABLE", "DISTINCT", "DO", "DOMAIN", "DOUBLE", "DROP", "EACH", "ELSE", "ENABLE",
+				"ENCODING", "ENCRYPTED", "END", "ESCAPE", "EXCEPT", "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXISTS",
+				"EXPLAIN", "EXTERNAL", "EXTERNALLY", "EXTRACT", "FALSE", "FETCH", "FILEGROWTH", "FILENAME", "FIRST",
+				"FLOAT", "FOR", "FORCE", "FOREIGN", "FORWARD", "FREEZE", "FROM", "FULL", "FUNCTION", "GETDATE",
+				"GLOBAL", "GRANT", "GRANTED", "GREATEST", "GROUP", "HANDLER", "HAVING", "HOLD", "HOUR", "IDENTIFIED",
+				"IDENTITY", "IF", "IFNULL", "ILIKE", "IMMEDIATE", "IMMUTABLE", "IMPLICIT", "IN", "INCLUDING",
+				"INCREMENT", "INDEX", "INDEXES", "INHERIT", "INHERITS", "INITIALLY", "INNER", "INOUT", "INPUT",
+				"INSENSITIVE", "INSERT", "INSTEAD", "INT", "INTEGER", "INTERNAL", "INTERSECT", "INTERVAL", "INTO",
+				"INVOKER", "IS", "ISNULL", "ISOLATION", "JOIN", "KEY", "LANCOMPILER", "LANGUAGE", "LARGE", "LAST",
+				"LEADING", "LEAST", "LEFT", "LEVEL", "LIKE", "LIMIT", "LINK", "LIST", "LISTEN", "LOAD", "LOCAL",
+				"LOCALTIME", "LOCALTIMESTAMP", "LOCATION", "LOCK", "LOGFILE", "LOGIN", "MATCH", "MAXSIZE", "MAXVALUE",
+				"MINUTE", "MINVALUE", "MODE", "MODIFY", "MONTH", "MOVE", "NAME", "NAMES", "NATIONAL", "NATURAL",
+				"NCHAR", "NEW", "NEXT", "NO", "NOALLOCATE", "NOCONSTRAINT", "NOCREATEDB", "NOCREATEROLE",
+				"NOCREATEUSER", "NOINDEX", "NOINHERIT", "NOLOGIN", "NONE", "NOSUPERUSER", "NOT", "NOTHING", "NOTIFY",
+				"NOTNULL", "NOWAIT", "NULL", "NULLIF", "NUMERIC", "OBJECT", "OF", "OFF", "OFFSET", "OIDS", "OLD", "ON",
+				"ONLY", "OPERATOR", "OPTION", "OR", "ORDER", "OUT", "OUTER", "OVERLAPS", "OVERLAY", "OWNED", "OWNER",
+				"PACKAGE", "PARTIAL", "PASSWORD", "PERCENT", "PLACING", "POSITION", "PRECISION", "PREPARE", "PREPARED",
+				"PRESERVE", "PRIMARY", "PRIOR", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", "QUOTE", "READ", "REAL",
+				"REASSIGN", "RECHECK", "REFERENCES", "REINDEX", "RELATIVE", "RELEASE", "REMOVE", "RENAME", "REPEATABLE",
+				"REPLACE", "RESET", "RESIZE", "RESTART", "RESTRICT", "RETURNING", "RETURNS", "REVOKE", "RIGHT", "ROLE",
+				"ROLLBACK", "ROW", "ROWNUM", "ROWS", "ROWTYPE", "RULE", "SAVEPOINT", "SCHEMA", "SCROLL", "SECOND",
+				"SECURITY", "SELECT", "SEQUENCE", "SERIALIZABLE", "SESSION", "SESSION_USER", "SET", "SETOF", "SHARE",
+				"SHOW", "SIMILAR", "SIMPLE", "SIZE", "SMALLINT", "SOME", "STABLE", "START", "STATEMENT", "STATISTICS",
+				"STDIN", "STDOUT", "STORAGE", "STRICT", "SUBSTRING", "SUPERUSER", "SWITCH", "SYMMETRIC", "SYSDATE",
+				"SYSID", "SYSTEM", "TABLE", "TABLESPACE", "TEMP", "TEMPFILE", "TEMPLATE", "TEMPORARY", "THEN", "TIME",
+				"TIMESTAMP", "TIMESTAMPADD", "TIMESTAMPDIFF", "TINYINT", "TO", "TOP", "TRAILING", "TRANSACTION",
+				"TREAT", "TRIGGER", "TRIM", "TRUE", "TRUNCATE", "TRUSTED", "TYPE", "UNCOMMITTED", "UNENCRYPTED",
+				"UNION", "UNIQUE", "UNKNOWN", "UNLISTEN", "UNTIL", "UPDATE", "USAGE", "USER", "USING", "VACUUM",
+				"VALID", "VALIDATOR", "VALUES", "VARCHAR", "VARCHAR2", "VARYING", "VERBOSE", "VIEW", "VOLATILE", "WHEN",
+				"WHERE", "WITH", "WITHOUT", "WORK", "WRITE", "YEAR", "ZONE", "BLOB", "BYTEA", "CLOB", "DATE", "TEXT",
+				"TIMESTAMPTZ", "TIMETZ", "RETURN", "ROWCOUNT", "CMAX", "CMIN", "CTID", "OID", "TABLEOID", "XMAX",
+				"XMIN" }));
+	}
+
+	public Date getDate(ResultSet paramResultSet, int paramInt) throws SQLException {
+		try {
+			return super.getDate(paramResultSet, paramInt);
+		} catch (StringIndexOutOfBoundsException localStringIndexOutOfBoundsException) {
+			String str = paramResultSet.getString(paramInt);
+			SimpleDateFormat localSimpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss.SS");
+			try {
+				return localSimpleDateFormat.parse(str);
+			} catch (ParseException localParseException) {
+				throw new SQLException(localParseException.toString());
+			}
+		}
+	}
+
+	public void setBoolean(PreparedStatement paramPreparedStatement, int paramInt, boolean paramBoolean,
+			Column paramColumn) throws SQLException {
+		paramPreparedStatement.setBoolean(paramInt, paramBoolean);
+	}
+
+	protected void appendSelectRange(SQLBuffer paramSQLBuffer, long paramLong1, long paramLong2, boolean paramBoolean) {
+		if (paramLong2 != Long.MAX_VALUE) {
+			paramSQLBuffer.append(" LIMIT ").appendValue(paramLong2 - paramLong1);
+		}
+		if (paramLong1 != 0L) {
+			paramSQLBuffer.append(" OFFSET ").appendValue(paramLong1);
+		}
+	}
+
+	public void indexOf(SQLBuffer paramSQLBuffer, FilterValue paramFilterValue1, FilterValue paramFilterValue2,
+			FilterValue paramFilterValue3) {
+		paramSQLBuffer.append("(POSITION(");
+		paramFilterValue2.appendTo(paramSQLBuffer);
+		paramSQLBuffer.append(" IN ");
+		if (paramFilterValue3 != null) {
+			substring(paramSQLBuffer, paramFilterValue1, paramFilterValue3, null);
+		} else {
+			paramFilterValue1.appendTo(paramSQLBuffer);
+		}
+		paramSQLBuffer.append(") - 1");
+		if (paramFilterValue3 != null) {
+			paramSQLBuffer.append(" + ");
+			paramFilterValue3.appendTo(paramSQLBuffer);
+		}
+		paramSQLBuffer.append(")");
+	}
+
+	public String[] getCreateSequenceSQL(Sequence paramSequence) {
+		String[] arrayOfString = super.getCreateSequenceSQL(paramSequence);
+		if (paramSequence.getAllocate() > 1) {
+			int tmp23_22 = 0;
+			String[] tmp23_21 = arrayOfString;
+			tmp23_21[tmp23_22] = (tmp23_21[tmp23_22] + " CACHE " + paramSequence.getAllocate());
+		}
+		return arrayOfString;
+	}
+
+	protected String getSequencesSQL(String paramString1, String paramString2) {
+		if ((paramString1 == null) && (paramString2 == null)) {
+			return this.allSequencesSQL;
+		}
+		if (paramString1 == null) {
+			return this.namedSequencesFromAllSchemasSQL;
+		}
+		if (paramString2 == null) {
+			return this.allSequencesFromOneSchemaSQL;
+		}
+		return this.namedSequenceFromOneSchemaSQL;
+	}
+
+	public boolean isSystemSequence(String paramString1, String paramString2, boolean paramBoolean) {
+		if (super.isSystemSequence(paramString1, paramString2, paramBoolean)) {
+			return true;
+		}
+		int i = paramString1.indexOf('_');
+		return (i != -1) && (i != paramString1.length() - 4) && (paramString1.toUpperCase().endsWith("_SEQ"));
+	}
+
+	public boolean isSystemTable(String paramString1, String paramString2, boolean paramBoolean) {
+		return (super.isSystemTable(paramString1, paramString2, paramBoolean))
+				|| ((paramString1 != null) && (paramString1.toLowerCase().startsWith("sys_")));
+	}
+
+	public boolean isSystemIndex(String paramString, Table paramTable) {
+		return (super.isSystemIndex(paramString, paramTable))
+				|| ((paramString != null) && (paramString.toLowerCase().startsWith("sys_")));
+	}
+
+	public Connection decorate(Connection paramConnection) throws SQLException {
+		return new KingbaseConnection(super.decorate(paramConnection), this);
+	}
+
+	private static class KingbasePreparedStatement extends DelegatingPreparedStatement {
+		public KingbasePreparedStatement(PreparedStatement paramPreparedStatement, Connection paramConnection,
+				KingbaseDictionary3 paramKingbaseDictionary) {
+			super(paramPreparedStatement, paramConnection);
+		}
+
+		protected ResultSet executeQuery(boolean paramBoolean) throws SQLException {
+			try {
+				return super.executeQuery(paramBoolean);
+			} catch (SQLException localSQLException) {
+				ResultSet localResultSet = getResultSet(paramBoolean);
+				if (localResultSet == null) {
+					throw localSQLException;
+				}
+				return localResultSet;
+			}
+		}
+	}
+
+	private static class KingbaseConnection extends DelegatingConnection {
+		private final KingbaseDictionary3 _dict;
+
+		public KingbaseConnection(Connection paramConnection, KingbaseDictionary3 paramKingbaseDictionary) {
+			super(paramConnection);
+			this._dict = paramKingbaseDictionary;
+		}
+
+		protected PreparedStatement prepareStatement(String paramString, boolean paramBoolean) throws SQLException {
+			return new KingbaseDictionary3.KingbasePreparedStatement(super.prepareStatement(paramString, false), this,
+					this._dict);
+		}
+
+		protected PreparedStatement prepareStatement(String paramString, int paramInt1, int paramInt2,
+				boolean paramBoolean) throws SQLException {
+			return new KingbaseDictionary3.KingbasePreparedStatement(
+					super.prepareStatement(paramString, paramInt1, paramInt2, false), this, this._dict);
+		}
+	}
+}

o2server/x_base_core_project/src/main/java/com/x/base/core/project/annotation/Describe.java

@@ -154,9 +154,13 @@ public class Describe {
 		if (null != wiClass) {
 			jaxrsMethod.setIns(this.jaxrsInField(wiClass));
 		} else {
-			/** 如果没有定义Wi对象,那么有可能使用的是jsonElement对象 */
-			if (ArrayUtils.contains(method.getParameterTypes(), JsonElement.class)) {
-				jaxrsMethod.setUseJsonElementParameter(true);
+			if (StringUtils.equals("POST", jaxrsMethod.getType()) || StringUtils.equals("PUT", jaxrsMethod.getType())) {
+				/** 如果没有定义Wi对象,那么有可能使用的是jsonElement对象 */
+				if (ArrayUtils.contains(method.getParameterTypes(), JsonElement.class)) {
+					jaxrsMethod.setUseJsonElementParameter(true);
+				} else {
+					jaxrsMethod.setUseStringParameter(true);
+				}
 			}
 		}
 		Consumes consumes = method.getAnnotation(Consumes.class);
@@ -481,6 +485,7 @@ public class Describe {
 		private String contentType;
 		private String resultContentType;
 		private Boolean useJsonElementParameter = false;
+		private Boolean useStringParameter = false;
 		private List<JaxrsPathParameter> pathParameters = new ArrayList<>();
 		private List<JaxrsFormParameter> formParameters = new ArrayList<>();
 		private List<JaxrsQueryParameter> queryParameters = new ArrayList<>();
@@ -591,6 +596,14 @@ public class Describe {
 			this.resultContentType = resultContentType;
 		}
 
+		public Boolean getUseStringParameter() {
+			return useStringParameter;
+		}
+
+		public void setUseStringParameter(Boolean useStringParameter) {
+			this.useStringParameter = useStringParameter;
+		}
+
 	}
 
 	public class JaxrsField {