From 18ba24a7308768e3ebac3508a3385ef48d255461 Mon Sep 17 00:00:00 2001 From: SolisAmicus Date: Sat, 21 Sep 2024 12:09:30 +0800 Subject: [PATCH] test: Add unit tests for OpenGaussDialect - Added unit tests for column type mappings. - Verified correct SQL function registration for OpenGauss functions. --- .idea/.gitignore | 8 + .idea/examples.iml | 9 + .idea/inspectionProfiles/Project_Default.xml | 6 + .idea/misc.xml | 6 + .idea/modules.xml | 8 + .idea/vcs.xml | 6 + openGaussDialect/.idea/.gitignore | 8 + openGaussDialect/.idea/compiler.xml | 14 + openGaussDialect/.idea/encodings.xml | 7 + openGaussDialect/.idea/jarRepositories.xml | 25 + openGaussDialect/.idea/misc.xml | 12 + openGaussDialect/.idea/modules.xml | 8 + openGaussDialect/.idea/uiDesigner.xml | 124 +++++ openGaussDialect/.idea/vcs.xml | 6 + openGaussDialect/openGaussDialect.iml | 12 + .../src/main/resources/hibernate.cfg.xml | 16 + .../dialect/entity/datatype/BinaryEntity.java | 23 + .../entity/datatype/BooleanEntity.java | 23 + .../dialect/entity/datatype/CharEntity.java | 19 + .../entity/datatype/DateTimeEntity.java | 29 ++ .../dialect/entity/datatype/JsonEntity.java | 37 ++ .../dialect/entity/datatype/LobEntity.java | 27 ++ .../entity/datatype/NationalizedEntity.java | 28 ++ .../dialect/entity/datatype/NumberEntity.java | 30 ++ .../dialect/entity/datatype/StringEntity.java | 26 ++ .../dialect/entity/function/TestEntity.java | 20 + .../org/hibernate/dialect/pojo/Person.java | 15 + .../dialect/unit/OpenGaussFunctionTest.java | 434 ++++++++++++++++++ .../unit/OpenGaussTypeMappingTest.java | 135 ++++++ .../hibernate/dialect/util/HibernateUtil.java | 16 + .../org/hibernate/dialect/util/JDBCUtil.java | 38 ++ .../target/classes/hibernate.cfg.xml | 16 + .../dialect/OpenGaussDialect$1.class | Bin 0 -> 1382 bytes .../dialect/OpenGaussDialect$2.class | Bin 0 -> 2746 bytes .../dialect/OpenGaussDialect$3.class | Bin 0 -> 1610 bytes .../dialect/OpenGaussDialect$4.class | Bin 0 -> 824 bytes .../hibernate/dialect/OpenGaussDialect.class | Bin 0 -> 15104 bytes .../dialect/function/SubstringFunction.class | Bin 0 -> 1973 bytes .../OpenGaussIdentityColumnSupport.class | Bin 0 -> 1316 bytes .../org/hibernate/dialect/type/JsonType.class | Bin 0 -> 3953 bytes .../hibernate/dialect/type/JsonbType.class | Bin 0 -> 4821 bytes .../dialect/entity/function/TestEntity.class | Bin 0 -> 2533 bytes .../org/hibernate/dialect/pojo/Person.class | Bin 0 -> 2235 bytes .../dialect/unit/OpenGaussFunctionTest.class | Bin 0 -> 15782 bytes 44 files changed, 1191 insertions(+) create mode 100644 .idea/.gitignore create mode 100644 .idea/examples.iml create mode 100644 .idea/inspectionProfiles/Project_Default.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/modules.xml create mode 100644 .idea/vcs.xml create mode 100644 openGaussDialect/.idea/.gitignore create mode 100644 openGaussDialect/.idea/compiler.xml create mode 100644 openGaussDialect/.idea/encodings.xml create mode 100644 openGaussDialect/.idea/jarRepositories.xml create mode 100644 openGaussDialect/.idea/misc.xml create mode 100644 openGaussDialect/.idea/modules.xml create mode 100644 openGaussDialect/.idea/uiDesigner.xml create mode 100644 openGaussDialect/.idea/vcs.xml create mode 100644 openGaussDialect/openGaussDialect.iml create mode 100644 openGaussDialect/src/main/resources/hibernate.cfg.xml create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/BinaryEntity.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/BooleanEntity.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/CharEntity.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/DateTimeEntity.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/JsonEntity.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/LobEntity.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/NationalizedEntity.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/NumberEntity.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/StringEntity.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/entity/function/TestEntity.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/pojo/Person.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/unit/OpenGaussFunctionTest.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/unit/OpenGaussTypeMappingTest.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/util/HibernateUtil.java create mode 100644 openGaussDialect/src/test/java/org/hibernate/dialect/util/JDBCUtil.java create mode 100644 openGaussDialect/target/classes/hibernate.cfg.xml create mode 100644 openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$1.class create mode 100644 openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$2.class create mode 100644 openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$3.class create mode 100644 openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$4.class create mode 100644 openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect.class create mode 100644 openGaussDialect/target/classes/org/hibernate/dialect/function/SubstringFunction.class create mode 100644 openGaussDialect/target/classes/org/hibernate/dialect/identity/OpenGaussIdentityColumnSupport.class create mode 100644 openGaussDialect/target/classes/org/hibernate/dialect/type/JsonType.class create mode 100644 openGaussDialect/target/classes/org/hibernate/dialect/type/JsonbType.class create mode 100644 openGaussDialect/target/test-classes/org/hibernate/dialect/entity/function/TestEntity.class create mode 100644 openGaussDialect/target/test-classes/org/hibernate/dialect/pojo/Person.class create mode 100644 openGaussDialect/target/test-classes/org/hibernate/dialect/unit/OpenGaussFunctionTest.class diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 00000000..13566b81 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/examples.iml b/.idea/examples.iml new file mode 100644 index 00000000..d6ebd480 --- /dev/null +++ b/.idea/examples.iml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 00000000..03d9549e --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 00000000..639900d1 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 00000000..704ff0e8 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 00000000..35eb1ddf --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/openGaussDialect/.idea/.gitignore b/openGaussDialect/.idea/.gitignore new file mode 100644 index 00000000..13566b81 --- /dev/null +++ b/openGaussDialect/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/openGaussDialect/.idea/compiler.xml b/openGaussDialect/.idea/compiler.xml new file mode 100644 index 00000000..b60f12a6 --- /dev/null +++ b/openGaussDialect/.idea/compiler.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/openGaussDialect/.idea/encodings.xml b/openGaussDialect/.idea/encodings.xml new file mode 100644 index 00000000..aa00ffab --- /dev/null +++ b/openGaussDialect/.idea/encodings.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/openGaussDialect/.idea/jarRepositories.xml b/openGaussDialect/.idea/jarRepositories.xml new file mode 100644 index 00000000..2661ae01 --- /dev/null +++ b/openGaussDialect/.idea/jarRepositories.xml @@ -0,0 +1,25 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/openGaussDialect/.idea/misc.xml b/openGaussDialect/.idea/misc.xml new file mode 100644 index 00000000..67e1e611 --- /dev/null +++ b/openGaussDialect/.idea/misc.xml @@ -0,0 +1,12 @@ + + + + + + + + \ No newline at end of file diff --git a/openGaussDialect/.idea/modules.xml b/openGaussDialect/.idea/modules.xml new file mode 100644 index 00000000..466a0c6d --- /dev/null +++ b/openGaussDialect/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/openGaussDialect/.idea/uiDesigner.xml b/openGaussDialect/.idea/uiDesigner.xml new file mode 100644 index 00000000..2b63946d --- /dev/null +++ b/openGaussDialect/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/openGaussDialect/.idea/vcs.xml b/openGaussDialect/.idea/vcs.xml new file mode 100644 index 00000000..6c0b8635 --- /dev/null +++ b/openGaussDialect/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/openGaussDialect/openGaussDialect.iml b/openGaussDialect/openGaussDialect.iml new file mode 100644 index 00000000..39cf9e32 --- /dev/null +++ b/openGaussDialect/openGaussDialect.iml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/openGaussDialect/src/main/resources/hibernate.cfg.xml b/openGaussDialect/src/main/resources/hibernate.cfg.xml new file mode 100644 index 00000000..3b36d8fa --- /dev/null +++ b/openGaussDialect/src/main/resources/hibernate.cfg.xml @@ -0,0 +1,16 @@ + + + + + org.opengauss.Driver + jdbc:opengauss://43.138.80.125:25432/osapp + postgres + osapp_openGauss@123 + org.hibernate.dialect.OpenGaussDialect + true + true + create-drop + + \ No newline at end of file diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/BinaryEntity.java b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/BinaryEntity.java new file mode 100644 index 00000000..fc017d79 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/BinaryEntity.java @@ -0,0 +1,23 @@ +package org.hibernate.dialect.entity.datatype; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.persistence.*; + +@Entity +@Table(name = "binary_test_table") +@Data +@NoArgsConstructor +@AllArgsConstructor +public class BinaryEntity { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + private byte[] binaryField; + @Column(name = "varBinaryField", columnDefinition = "bytea") + private byte[] varBinaryField; + @Column(name = "longVarBinaryField", columnDefinition = "bytea") + private byte[] longVarBinaryField; +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/BooleanEntity.java b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/BooleanEntity.java new file mode 100644 index 00000000..280c88d6 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/BooleanEntity.java @@ -0,0 +1,23 @@ +package org.hibernate.dialect.entity.datatype; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.persistence.*; + +@Entity +@Table(name = "bool_test_table") +@Data +@NoArgsConstructor +@AllArgsConstructor +public class BooleanEntity { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + + private Boolean booleanField; + + @Column(columnDefinition = "bit") + private Boolean bitField; +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/CharEntity.java b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/CharEntity.java new file mode 100644 index 00000000..90df8382 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/CharEntity.java @@ -0,0 +1,19 @@ +package org.hibernate.dialect.entity.datatype; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.persistence.*; + +@Entity +@Table(name = "char_test_table") +@Data +@NoArgsConstructor +@AllArgsConstructor +public class CharEntity { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + private Character characterField; +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/DateTimeEntity.java b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/DateTimeEntity.java new file mode 100644 index 00000000..3e12e6b3 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/DateTimeEntity.java @@ -0,0 +1,29 @@ +package org.hibernate.dialect.entity.datatype; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.persistence.*; +import java.sql.Date; +import java.sql.Time; +import java.sql.Timestamp; + +@Entity +@Table(name = "date_time_test_table") +@Data +@NoArgsConstructor +@AllArgsConstructor +public class DateTimeEntity { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + + private Date dateField; + private Time timeField; + private Timestamp timestampField; + @Column(name = "timetzField", columnDefinition = "timetz") + private Timestamp timetzField; + @Column(name = "timestamptzField", columnDefinition = "timestamptz") + private Timestamp timestamptzField; +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/JsonEntity.java b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/JsonEntity.java new file mode 100644 index 00000000..890b610b --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/JsonEntity.java @@ -0,0 +1,37 @@ +package org.hibernate.dialect.entity.datatype; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.annotations.Type; +import org.hibernate.annotations.TypeDef; +import org.hibernate.annotations.TypeDefs; +import org.hibernate.dialect.pojo.Person; +import org.hibernate.dialect.type.JsonType; +import org.hibernate.dialect.type.JsonbType; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; + +@Entity +@Table(name = "test_table") +@Data +@NoArgsConstructor +@AllArgsConstructor +@TypeDefs({ + @TypeDef(name = "jsonb", typeClass = JsonbType.class), + @TypeDef(name = "json", typeClass = JsonType.class), +}) +public class JsonEntity { + @Id + private Long id; + + @Type(type = "json") + private Person pojoJson; + + @Type(type = "jsonb") + @Column(columnDefinition = "jsonb") + private Person pojoJsonb; +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/LobEntity.java b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/LobEntity.java new file mode 100644 index 00000000..f4e6fa6d --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/LobEntity.java @@ -0,0 +1,27 @@ +package org.hibernate.dialect.entity.datatype; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.persistence.*; +import java.sql.Blob; +import java.sql.Clob; +import java.sql.NClob; + +@Entity +@Table(name = "lob_test_table") +@Data +@NoArgsConstructor +@AllArgsConstructor +public class LobEntity { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + @Lob + private Blob blobField; // Blob --> blob + @Lob + private Clob clobField; // Clob --> clob + @Lob + private NClob nclobField; // NClob --> text +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/NationalizedEntity.java b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/NationalizedEntity.java new file mode 100644 index 00000000..4f383dad --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/NationalizedEntity.java @@ -0,0 +1,28 @@ +package org.hibernate.dialect.entity.datatype; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.annotations.Nationalized; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Lob; +import javax.persistence.Table; + +@Entity +@Table(name = "nationalized_table") +@Data +@NoArgsConstructor +@AllArgsConstructor +public class NationalizedEntity { + @Id + private Long id; + @Nationalized + private String nvarcharData; + @Nationalized + private Character ncharData; + @Lob + @Nationalized + private String nclobData; +} \ No newline at end of file diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/NumberEntity.java b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/NumberEntity.java new file mode 100644 index 00000000..562f7924 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/NumberEntity.java @@ -0,0 +1,30 @@ +package org.hibernate.dialect.entity.datatype; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; +import java.math.BigDecimal; + +@Entity +@Table(name = "number_test_table") +@Data +@NoArgsConstructor +@AllArgsConstructor +public class NumberEntity { + @Id + private Long id; + private Byte tinyIntField; + private Short smallIntField; + private Integer integerField; + private Long bigIntField; + private Float floatField; + private Double doubleField; + @Column(columnDefinition = "decimal(19, 2)") + private BigDecimal decimalField; + private BigDecimal numericField; +} \ No newline at end of file diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/StringEntity.java b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/StringEntity.java new file mode 100644 index 00000000..275583ca --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/datatype/StringEntity.java @@ -0,0 +1,26 @@ +package org.hibernate.dialect.entity.datatype; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.annotations.Nationalized; + +import javax.persistence.*; + +@Entity +@Table(name = "string_test_table") +@Data +@NoArgsConstructor +@AllArgsConstructor +public class StringEntity { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + private String varCharField; + @Column(name = "longVarCharField", columnDefinition = "text") + private String longVarCharField; + @Nationalized + private Character nCharField; + @Nationalized + private String nVarCharField; +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/entity/function/TestEntity.java b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/function/TestEntity.java new file mode 100644 index 00000000..ef7b5250 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/entity/function/TestEntity.java @@ -0,0 +1,20 @@ +package org.hibernate.dialect.entity.function; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.persistence.*; + +@Entity +@Table(name = "test_table") +@Data +@NoArgsConstructor +@AllArgsConstructor +public class TestEntity { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + private Double value; +} + diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/pojo/Person.java b/openGaussDialect/src/test/java/org/hibernate/dialect/pojo/Person.java new file mode 100644 index 00000000..8e62d402 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/pojo/Person.java @@ -0,0 +1,15 @@ +package org.hibernate.dialect.pojo; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; + +@NoArgsConstructor +@AllArgsConstructor +@Data +public class Person implements Serializable { + private Integer id; + private String name; +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/unit/OpenGaussFunctionTest.java b/openGaussDialect/src/test/java/org/hibernate/dialect/unit/OpenGaussFunctionTest.java new file mode 100644 index 00000000..2276e092 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/unit/OpenGaussFunctionTest.java @@ -0,0 +1,434 @@ +package org.hibernate.dialect.unit; + +import org.hibernate.Session; +import org.hibernate.SessionFactory; +import org.hibernate.Transaction; +import org.hibernate.dialect.entity.function.TestEntity; +import org.hibernate.dialect.util.HibernateUtil; +import org.hibernate.query.Query; +import org.hibernate.type.StandardBasicTypes; +import org.junit.jupiter.api.*; + +import java.math.BigDecimal; +import java.text.SimpleDateFormat; +import java.util.Date; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class OpenGaussFunctionTest { + private static SessionFactory sessionFactory; + + private Session session; + + @BeforeAll + public static void setUpAll() { + sessionFactory = HibernateUtil.getSessionFactory(TestEntity.class); + } + + @BeforeEach + public void setUp() { + session = sessionFactory.openSession(); + session.beginTransaction(); + session.createQuery("DELETE FROM TestEntity").executeUpdate(); + session.getTransaction().commit(); + } + + @AfterEach + public void tearDown() { + if (session != null) { + session.close(); + } + } + + @AfterAll + public static void tearDownALL() { + if (sessionFactory != null) { + sessionFactory.close(); + } + } + + public static String bytesToHex(byte[] bytes) { + StringBuilder hexString = new StringBuilder(); + for (byte b : bytes) { + String hex = Integer.toHexString(0xff & b); + if (hex.length() == 1) hexString.append('0'); + hexString.append(hex); + } + return hexString.toString(); + } + + @Test + public void testTypeMapping() { + Transaction transaction = session.beginTransaction(); + transaction.commit(); + } + + @Test + public void testMathFunctions() { + Transaction transaction = session.beginTransaction(); + TestEntity testEntity = new TestEntity(); + testEntity.setValue(0.0); + session.save(testEntity); + transaction.commit(); + + // Test abs function + Query absQuery = session.createQuery("select abs(-17.4) from TestEntity", Double.class); + Double absResult = absQuery.getSingleResult(); + assertEquals(17.4, absResult, 0.001); + + // Test cbrt function + Query cbrtQuery = session.createQuery("select cbrt(27.0) from TestEntity", Double.class); + Double cbrtResult = cbrtQuery.getSingleResult(); + assertEquals(3.0, cbrtResult, 0.001); + + // Test ceil function + Query ceilQuery = session.createQuery("select ceil(-42.8) from TestEntity", Double.class); + Double ceilResult = ceilQuery.getSingleResult(); + assertEquals(-42L, ceilResult); + + // Test degrees function + Query degreesQuery = session.createQuery("select degrees(0.5) from TestEntity", Double.class); + Double degreesResult = degreesQuery.getSingleResult(); + assertEquals(28.6478897565412, degreesResult, 0.001); + + // Test exp function + Query expQuery = session.createQuery("select exp(1.0) from TestEntity", Double.class); + Double expResult = expQuery.getSingleResult(); + assertEquals(2.718281828459045, expResult, 0.001); + + // Test floor function + Query floorQuery = session.createQuery("select floor(-42.8) from TestEntity", Double.class); + Double floorResult = floorQuery.getSingleResult(); + assertEquals(-43L, floorResult); + + // Test ln function + Query lnQuery = session.createQuery("select ln(2.0) from TestEntity", Double.class); + Double lnResult = lnQuery.getSingleResult(); + assertEquals(0.6931471805599453, lnResult, 0.001); + + // Test log function + Query logQuery = session.createQuery("select log(100.0) from TestEntity", Double.class); + Double logResult = logQuery.getSingleResult(); + assertEquals(2.0, logResult, 0.001); + + // Test mod function + Query modQuery = session.createQuery("select mod(9, 4) from TestEntity", Integer.class); + Integer modResult = modQuery.getSingleResult(); + assertEquals(1, modResult.intValue()); + + // Test pi function + Query piQuery = session.createQuery("select pi() from TestEntity", Double.class); + Double piResult = piQuery.getSingleResult(); + assertEquals(3.14159265358979, piResult, 0.001); + + // Test power function + Query powerQuery = session.createQuery("select power(9.0, 3.0) from TestEntity", Double.class); + Double powerResult = powerQuery.getSingleResult(); + assertEquals(729.0, powerResult, 0.001); + + // Test radians function + Query radiansQuery = session.createQuery("select radians(45.0) from TestEntity", Double.class); + Double radiansResult = radiansQuery.getSingleResult(); + assertEquals(0.7853981633974483, radiansResult, 0.001); + + // Test random function + Query randomQuery = session.createQuery("select random() from TestEntity", Double.class); + Double randomResult = randomQuery.getSingleResult(); + assertTrue(randomResult >= 0.0 && randomResult <= 1.0); + + // Test round function + Query roundQuery = session.createQuery("select round(42.6) from TestEntity", Double.class); + Double roundResult = roundQuery.getSingleResult(); + assertEquals(43L, roundResult); + + // Test sign function + Query signQuery = session.createQuery("select sign(-8.4) from TestEntity", Integer.class); + Integer signResult = signQuery.getSingleResult(); + assertEquals(-1, signResult.intValue()); + + // Test sqrt function + Query sqrtQuery = session.createQuery("select sqrt(2.0) from TestEntity", Double.class); + Double sqrtResult = sqrtQuery.getSingleResult(); + assertEquals(1.4142135623730951, sqrtResult, 0.001); + + // Test trunc function + Query truncQuery = session.createQuery("select trunc(42.8) from TestEntity", Double.class); + Double truncResult = truncQuery.getSingleResult(); + assertEquals(42L, truncResult); + } + + @Test + public void testTrigonometryFunctions() { + Transaction transaction = session.beginTransaction(); + TestEntity testEntity = new TestEntity(); + testEntity.setValue(0.0); + session.save(testEntity); + transaction.commit(); + + // Test acos function + Query acosQuery = session.createQuery("select acos(-1) from TestEntity", Double.class); + Double acosResult = acosQuery.getSingleResult(); + assertEquals(Math.PI, acosResult, 0.0001); + + // Test asin function + Query asinQuery = session.createQuery("select asin(0.5) from TestEntity", Double.class); + Double asinResult = asinQuery.getSingleResult(); + assertEquals(Math.asin(0.5), asinResult, 0.0001); + + // Test atan function + Query atanQuery = session.createQuery("select atan(1) from TestEntity", Double.class); + Double atanResult = atanQuery.getSingleResult(); + assertEquals(Math.atan(1), atanResult, 0.0001); + + // Test atan2 function + Query atan2Query = session.createQuery("select atan2(2, 1) from TestEntity", Double.class); + Double atan2Result = atan2Query.getSingleResult(); + assertEquals(Math.atan2(2, 1), atan2Result, 0.0001); + + // Test cos function + Query cosQuery = session.createQuery("select cos(-3.1415927) from TestEntity", Double.class); + Double cosResult = cosQuery.getSingleResult(); + assertEquals(Math.cos(-3.1415927), cosResult, 0.0001); + + // Test cot function + Query cotQuery = session.createQuery("select cot(1) from TestEntity", Double.class); + Double cotResult = cotQuery.getSingleResult(); + assertEquals(1.0 / Math.tan(1), cotResult, 0.0001); + + // Test sin function + Query sinQuery = session.createQuery("select sin(1.57079) from TestEntity", Double.class); + Double sinResult = sinQuery.getSingleResult(); + assertEquals(Math.sin(1.57079), sinResult, 0.0001); + + // Test tan function + Query tanQuery = session.createQuery("select tan(20) from TestEntity", Double.class); + Double tanResult = tanQuery.getSingleResult(); + assertEquals(Math.tan(20), tanResult, 0.0001); + } + + @Test + public void testStringFunctions() { + Transaction transaction = session.beginTransaction(); + TestEntity testEntity = new TestEntity(); + testEntity.setValue(0.0); + session.save(testEntity); + transaction.commit(); + + // Test string concatenation + Query concatQuery = session.createQuery("select 'MPP' || 'DB' as result from TestEntity", String.class); + String concatResult = concatQuery.getSingleResult(); + assertEquals("MPPDB", concatResult); + + // Test convert function + Query query = session.createQuery("select convert('text_in_utf8', 'UTF8', 'GBK') from TestEntity", byte[].class); + byte[] convertResult = query.getSingleResult(); + String hexResult = "\\x" + bytesToHex(convertResult); + assertEquals("\\x746578745f696e5f75746638", hexResult); + + // Test bit_length function + Query bitLengthQuery = session.createQuery("select bit_length('world') from TestEntity", Long.class); + Long bitLengthResult = bitLengthQuery.getSingleResult(); + assertEquals(40, bitLengthResult.intValue()); + + // Test lower function + Query lowerQuery = session.createQuery("select lower('TOM') from TestEntity", String.class); + String lowerResult = lowerQuery.getSingleResult(); + assertEquals("tom", lowerResult); + + // Test overlay function + Query overlayQuery = session.createQuery("select overlay('hello','world',2,3) from TestEntity", String.class); + String overlayResult = overlayQuery.getSingleResult(); + assertEquals("hworldo", overlayResult); + + // Test position function + Query positionQuery = session.createQuery("select position('ing','string') from TestEntity", Integer.class); + Integer positionResult = positionQuery.getSingleResult(); + assertEquals(4, positionResult.intValue()); + + // Test substring function (with start and length) + Query substringQuery = session.createQuery("select substring('Thomas',2,3) from TestEntity", String.class); + String substringResult = substringQuery.getSingleResult(); + assertEquals("hom", substringResult); + + substringQuery = session.createQuery("select substring('Thomas','...$') from TestEntity", String.class); + substringResult = substringQuery.getSingleResult(); + assertEquals("mas", substringResult); + + substringQuery = session.createQuery("select substring('foobar','o(.)b') from TestEntity", String.class); + substringResult = substringQuery.getSingleResult(); + assertEquals("o", substringResult); + + substringQuery = session.createQuery("select substring('foobar','(o(.)b)') from TestEntity", String.class); + substringResult = substringQuery.getSingleResult(); + assertEquals("oob", substringResult); + + // Test trim function + Query trimQuery = session.createQuery("select trim(both 'x' from 'xTomxx') from TestEntity", String.class); + String trimResult = trimQuery.getSingleResult(); + assertEquals("Tom", trimResult); + + // Test upper function + Query upperQuery = session.createQuery("select upper('tom') from TestEntity", String.class); + String upperResult = upperQuery.getSingleResult(); + assertEquals("TOM", upperResult); + + // Test ascii function + Query asciiQuery = session.createQuery("select ascii('xyz') from TestEntity", Integer.class); + Integer asciiResult = asciiQuery.getSingleResult(); + assertEquals(120, asciiResult.intValue()); + + // Test btrim function + Query btrimQuery = session.createQuery("select btrim('sring','ing') from TestEntity", String.class); + String btrimResult = btrimQuery.getSingleResult(); + assertEquals("sr", btrimResult); + + // Test char function + Query chrQuery = session.createQuery("select chr(65) from TestEntity", Character.class); + Character chrResult = chrQuery.getSingleResult(); + assertEquals('A', chrResult); + + // Test initcap function + Query initcapQuery = session.createQuery("select initcap('hi THOMAS') from TestEntity", String.class); + String initcapResult = initcapQuery.getSingleResult(); + assertEquals("Hi Thomas", initcapResult); + + // Test length function + Query lengthQuery = session.createQuery("select length('abcd') from TestEntity", Integer.class); + Integer lengthResult = lengthQuery.getSingleResult(); + assertEquals(4, lengthResult.intValue()); + + // Test lpad function + Query lpadQuery = session.createQuery("select lpad('hi', 5, 'xyza') from TestEntity", String.class); + String lpadResult = lpadQuery.getSingleResult(); + assertEquals("xyzhi", lpadResult); + + // Test ltrim function + Query ltrimQuery = session.createQuery("select ltrim('xxxxTRIM','x') from TestEntity", String.class); + String ltrimResult = ltrimQuery.getSingleResult(); + assertEquals("TRIM", ltrimResult); + + // Test md5 function + Query md5Query = session.createQuery("select md5('ABC') from TestEntity", String.class); + String md5Result = md5Query.getSingleResult(); + assertEquals("902fbdd2b1df0c4f70b4a5d23525e932", md5Result); + + // Test repeat function + Query repeatQuery = session.createQuery("select repeat('Pg', 4) from TestEntity", String.class); + String repeatResult = repeatQuery.getSingleResult(); + assertEquals("PgPgPgPg", repeatResult); + + // Test replace function + Query replaceQuery = session.createQuery("select replace('abcdefabcdef', 'cd', 'XXX') from TestEntity", String.class); + String replaceResult = replaceQuery.getSingleResult(); + assertEquals("abXXXefabXXXef", replaceResult); + + // Test rpad function + Query rpadQuery = session.createQuery("select rpad('hi', 5, 'xy') from TestEntity", String.class); + String rpadResult = rpadQuery.getSingleResult(); + assertEquals("hixyx", rpadResult); + + // Test rtrim function + Query rtrimQuery = session.createQuery("select rtrim('trimxxxx', 'x') from TestEntity", String.class); + String rtrimResult = rtrimQuery.getSingleResult(); + assertEquals("trim", rtrimResult); + + // Test split_part function + Query splitPartQuery = session.createQuery("select split_part('abc~@~def~@~ghi', '~@~', 2) from TestEntity", String.class); + String splitPartResult = splitPartQuery.getSingleResult(); + assertEquals("def", splitPartResult); + + // Test strpos function + Query strposQuery = session.createQuery("select strpos('source', 'rc') from TestEntity", Integer.class); + Integer strposResult = strposQuery.getSingleResult(); + assertEquals(4, strposResult.intValue()); + + // Test to_hex function + Query toHexQuery = session.createQuery("select to_hex(2147483647) from TestEntity", String.class); + String toHexResult = toHexQuery.getSingleResult(); + assertEquals("7fffffff", toHexResult); + } + + @Test + public void toCharTest() { + Transaction transaction = session.beginTransaction(); + TestEntity testEntity = new TestEntity(); + testEntity.setValue(0.0); + session.save(testEntity); + transaction.commit(); + + Query translateQuery = session.createQuery("select translate('12345', '143', 'ax') from TestEntity", String.class); + String translateResult = translateQuery.getSingleResult(); + assertEquals("a2x5", translateResult); + + Query toCharQuery = session.createQuery("select to_char(current_timestamp, 'HH12:MI:SS') from TestEntity", String.class); + String toCharResult = toCharQuery.getSingleResult(); + System.out.println(toCharResult); + + toCharQuery = session.createNativeQuery( + "SELECT to_char(interval '15h 2m 12s', 'HH24:MI:SS') AS formatted_value") + .addScalar("formatted_value", StandardBasicTypes.STRING + ); + toCharResult = toCharQuery.getSingleResult(); + assertEquals("15:02:12", toCharResult); + + toCharQuery = session.createQuery("select to_char(125, '999') from TestEntity", String.class); + toCharResult = toCharQuery.getSingleResult(); + assertEquals(" 125", toCharResult); + + toCharQuery = session.createNativeQuery( + "SELECT to_char(CAST(125.8 AS REAL), '999D99') AS formatted_value") + .addScalar("formatted_value", StandardBasicTypes.STRING + ); + toCharResult = toCharQuery.getSingleResult(); + assertEquals(" 125.80", toCharResult); + + toCharQuery = session.createQuery("select to_char(-125.8, '999D99S') from TestEntity", String.class); + toCharResult = toCharQuery.getSingleResult(); + assertEquals("125.80-", toCharResult); + } + + @Test + public void toDateTest() { + Transaction transaction = session.beginTransaction(); + TestEntity testEntity = new TestEntity(); + testEntity.setValue(0.0); + session.save(testEntity); + transaction.commit(); + + Query toTimestampQuery = session.createQuery("select to_timestamp('05 Dec 2000', 'DD Mon YYYY') from TestEntity", Date.class); + Date result = toTimestampQuery.getSingleResult(); + System.out.println(result); + } + + @Test + public void toNumberTest() { + Transaction transaction = session.beginTransaction(); + TestEntity testEntity = new TestEntity(); + testEntity.setValue(0.0); + session.save(testEntity); + transaction.commit(); + + Query toNumberQuery = session.createQuery( + "select to_number('125.8', '999D99') from TestEntity", BigDecimal.class + ); + BigDecimal toNumberResult = toNumberQuery.getSingleResult(); + assertEquals(new BigDecimal("125.8"), toNumberResult); + } + + @Test + public void toTimeStampTest() { + Transaction transaction = session.beginTransaction(); + TestEntity testEntity = new TestEntity(); + testEntity.setValue(0.0); + session.save(testEntity); + transaction.commit(); + Query toTimestampQuery = session.createQuery( + "select to_timestamp('05 Dec 2000', 'DD Mon YYYY') from TestEntity", Date.class + ); + Date toTimestampResult = toTimestampQuery.getSingleResult(); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + String expectedTimestamp = "2000-12-05 00:00:00"; + assertEquals(expectedTimestamp, sdf.format(toTimestampResult)); + } +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/unit/OpenGaussTypeMappingTest.java b/openGaussDialect/src/test/java/org/hibernate/dialect/unit/OpenGaussTypeMappingTest.java new file mode 100644 index 00000000..937a90c8 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/unit/OpenGaussTypeMappingTest.java @@ -0,0 +1,135 @@ +package org.hibernate.dialect.unit; + +import org.hibernate.Session; +import org.hibernate.SessionFactory; +import org.hibernate.dialect.entity.datatype.*; +import org.hibernate.dialect.pojo.Person; +import org.hibernate.dialect.util.HibernateUtil; +import org.hibernate.dialect.util.JDBCUtil; +import org.junit.jupiter.api.Test; + +import java.sql.*; +import java.util.ArrayList; +import java.util.List; + + +public class OpenGaussTypeMappingTest { + private static SessionFactory sessionFactory; + + public static void formatColumns(List columns) { + int maxColumnLength = columns.stream().mapToInt(c -> c[0].length()).max().orElse(0); + int maxTypeLength = columns.stream().mapToInt(c -> c[1].length()).max().orElse(0); + for (String[] column : columns) { + System.out.printf("Column %-" + maxColumnLength + "s : %" + maxTypeLength + "s%n", column[0], column[1]); + } + } + + public static void ColumnFormatter(String tableName) { + List columns = null; + try { + Connection conn = JDBCUtil.getConnection(); + String sql = "SELECT * FROM " + tableName; + Statement stmt = conn.createStatement(); + ResultSet rs = stmt.executeQuery(sql); + ResultSetMetaData rsmd = rs.getMetaData(); + columns = new ArrayList<>(); + for (int i = 1; i <= rsmd.getColumnCount(); i++) { + String columnName = rsmd.getColumnName(i); + String columnType = rsmd.getColumnTypeName(i); + columns.add(new String[]{columnName, columnType}); + } + JDBCUtil.disconnect(conn); + } catch (Exception e) { + e.printStackTrace(); + } + formatColumns(columns); + } + + @Test + public void testBooleanMapping() { + sessionFactory = HibernateUtil.getSessionFactory(BooleanEntity.class); + Session session = sessionFactory.openSession(); + session.beginTransaction(); + session.getTransaction().commit(); + session.close(); + } + + @Test + public void testNumberMapping() { + sessionFactory = HibernateUtil.getSessionFactory(NumberEntity.class); + Session session = sessionFactory.openSession(); + session.beginTransaction(); + session.getTransaction().commit(); + session.close(); + } + + @Test + public void testCharMapping() { + sessionFactory = HibernateUtil.getSessionFactory(CharEntity.class); + Session session = sessionFactory.openSession(); + session.beginTransaction(); + session.getTransaction().commit(); + session.close(); + } + + @Test + public void testStringMapping() { + sessionFactory = HibernateUtil.getSessionFactory(StringEntity.class); + Session session = sessionFactory.openSession(); + session.beginTransaction(); + session.getTransaction().commit(); + session.close(); + } + + @Test + public void testDateTimeMapping() { + sessionFactory = HibernateUtil.getSessionFactory(DateTimeEntity.class); + Session session = sessionFactory.openSession(); + session.beginTransaction(); + session.getTransaction().commit(); + session.close(); + } + + @Test + public void testBinaryMapping() { + sessionFactory = HibernateUtil.getSessionFactory(BinaryEntity.class); + Session session = sessionFactory.openSession(); + session.beginTransaction(); + session.getTransaction().commit(); + session.close(); + } + + @Test + public void testLobMapping() { + sessionFactory = HibernateUtil.getSessionFactory(LobEntity.class); + Session session = sessionFactory.openSession(); + session.beginTransaction(); + session.getTransaction().commit(); + session.close(); + } + + @Test + public void testInsertAndRetrieveJsonData() { + sessionFactory = HibernateUtil.getSessionFactory(JsonEntity.class); + Session session = sessionFactory.openSession(); + session.beginTransaction(); + JsonEntity entity = new JsonEntity(); + entity.setId(1L); + entity.setPojoJson(new Person(1, "opengauss")); + entity.setPojoJsonb(new Person(2, "opengauss")); + session.save(entity); + session.getTransaction().commit(); + JsonEntity retrievedEntity = session.get(JsonEntity.class, entity.getId()); + System.out.println(retrievedEntity); + session.close(); + } + + @Test + public void testSupportsNationalizedTypes() { + sessionFactory = HibernateUtil.getSessionFactory(NationalizedEntity.class); + Session session = sessionFactory.openSession(); + session.beginTransaction(); + session.getTransaction().commit(); + session.close(); + } +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/util/HibernateUtil.java b/openGaussDialect/src/test/java/org/hibernate/dialect/util/HibernateUtil.java new file mode 100644 index 00000000..cc296dd1 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/util/HibernateUtil.java @@ -0,0 +1,16 @@ +package org.hibernate.dialect.util; + +import org.hibernate.SessionFactory; +import org.hibernate.cfg.Configuration; + +public class HibernateUtil { + public static SessionFactory getSessionFactory(Class... classes) { + Configuration configuration = new Configuration().configure(); + if (classes != null) { + for (Class c : classes) { + configuration.addAnnotatedClass(c); + } + } + return configuration.buildSessionFactory(); + } +} diff --git a/openGaussDialect/src/test/java/org/hibernate/dialect/util/JDBCUtil.java b/openGaussDialect/src/test/java/org/hibernate/dialect/util/JDBCUtil.java new file mode 100644 index 00000000..8f963bb6 --- /dev/null +++ b/openGaussDialect/src/test/java/org/hibernate/dialect/util/JDBCUtil.java @@ -0,0 +1,38 @@ +package org.hibernate.dialect.util; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +public class JDBCUtil { + private static String DRIVER = "org.opengauss.Driver"; + private static String URL = "jdbc:opengauss://43.138.80.125:25432/osapp"; + private static String USER = "postgres"; + private static String PASSWORD = "osapp_openGauss@123"; + + static { + try { + Class.forName(DRIVER); + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + } + + public static Connection getConnection() { + Connection connect = null; + try { + connect = DriverManager.getConnection(URL, USER, PASSWORD); + } catch (SQLException e) { + e.printStackTrace(); + } + return connect; + } + + public static void disconnect(Connection connection) { + try { + connection.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } +} diff --git a/openGaussDialect/target/classes/hibernate.cfg.xml b/openGaussDialect/target/classes/hibernate.cfg.xml new file mode 100644 index 00000000..3b36d8fa --- /dev/null +++ b/openGaussDialect/target/classes/hibernate.cfg.xml @@ -0,0 +1,16 @@ + + + + + org.opengauss.Driver + jdbc:opengauss://43.138.80.125:25432/osapp + postgres + osapp_openGauss@123 + org.hibernate.dialect.OpenGaussDialect + true + true + create-drop + + \ No newline at end of file diff --git a/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$1.class b/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$1.class new file mode 100644 index 0000000000000000000000000000000000000000..b0576bd02808233046f82588539be3b769a67b22 GIT binary patch literal 1382 zcma)6TTc@~6#k}N+_tm=6+{%YAeXjWRusIX2BRoSQp8Y0B5%`nXh)abb!Use#Ydlf z@j+j}XyOm>M~P>)#n3_{o9vmHZ_fG7b@%t5AHM)B;XwisL`@h;^xy)+vg_BZx-1Ld z;eoKKlG~yZSRSuQ0;KC$kIO3Xc_k>yJsG^^k--W>G@IK_AcnY!L=wG7 zGR*y#v&kiFPgC{QxmuIH3bx!24Eb!a-CQ^nim;R?Em9~69UsM2$nBW8$T0kt?{mxM zPR%L>zI19&8q%%`KY6kVi;zK9mCqsND^0ZjljTd2Es6yJ&+)kIn-t-5-cagkvk#Mt492Qk z6%2hvs=~|09(C$9FWZEqi*AM6+uWD>+yafDE)`X=qln!d6c`eo?^c9TrS~?&#u?S= zAnV$ZQ$-~5sM4(Iv##RmxS0$y=k&o4r*YW~yTHJ97*eHxSKe)KFRXxxd4~SZ{+h5D zrrK-XB?}@{4bOA^K!sBpPB^(4FH5HyBCoj5_e3CkweD<*eOkq)PZLLlEV&K8BG#mC z&roMG7j#tA$Y)N)b`?$Ph6w6z)xGs&VwTmIS?l{6&i7;a*cq&EIU+L~@+?mNttpGdtqMBnTI z`o}&ZmLB|!p7dop9pK7W(u#)6`mX{;{}h%A+4D_?7CUia3e%y-3Cti%+C3OU4tcVl zC6;+ajxYkl#Hfim6AKi-iPRC9oWvr8(LJHJu-FP$pLDJf1~-H1aRe+vl(x bKEpDKJ0brPmT5I`m*jnV6XboAR(k#dF1Sn( literal 0 HcmV?d00001 diff --git a/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$2.class b/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$2.class new file mode 100644 index 0000000000000000000000000000000000000000..5b33d4645c8dcb532bfe9a7b2a9bdd5179c38229 GIT binary patch literal 2746 zcmbtWOK?+V6#h)MqY_qg!!{r9GA(i+k6PfpI`p4Wf=^PijV|M=<~ z09|mZ5I|5vD26a1f|gu9lUTAA%zV~x&BUT**k;;IOs<;Qvqr&jhI~O&haloESx!@u zHe>(Js5c57RT`o(R3j#+y>8qv61I`eBqkTGGYoy6w6d1lCkVE*&PDMUYBbcwup4!P zM0pe|>#8K}M8UP}#QDXA^zhBJx$0WE>^ak3HS>ZR^QN0O((cTfJ>zmag7%g%FQ~I- zCuXL{HZ6KveYuy+jGMQz8D_f&^%@#t*o!C1vh@|1t!-vA?vj`7s8Zh-!+ty|sB#Jm zj^{oONO&Fm|HY;JR=BnbShtmVrar)1~JzPhV2OIi@BE+thaSu z$Fs_$Lq{udS5ikiaq@(Yqr~0aIuZ&W*YTVn+|k*cq^PqZ`PV8(RktenmIE)M3h+_u4^nJ`w&VZZw7Bu=-qZfg>AWt+_t#Q=s>PY(;GN)M^nNEKRc zXUFZ7w9aWbD>z&!ts%oTO7a-NsLJEKpzr_Wp`wlnl9i&4<9vC8Sn9f!Bya(v z8YXw#)vW_MKXhi0waoIims?IK%ZoeuZpw5VYsGS0E3KlIgql_cmjs8(vz#uN`PXKx z6*E_GOSET|_KSj^a_z0eR2P;`1SWaI%sWhS$h6JO#`GvRuXHPVTjvBJb)z|i#;mM4 zQCQ(foi!G0O6s^1!=5wpmg0-Tkea4~wr$s>QiP@s-cc>>CCRxtUumxGY^j}+?N?Ks z(Prrw<}rpTxz=g}Ta&xkre~Dc^ zp?K&!xf2hqx6-46h^J6OM;_B7u|^kF4Xsr=G8O`OC~AI`J}bKk)_P0pecb zH;9=}~3N6($@ed`tL&@FU@8!msgAj~+->#dU5)8E}mUetM^Y z5GUPFNGchjF|OAo{rJIDm5Q&|b@=f^imxT#<;M@Fs_LthyKaJ7>U@+x58A$ftRvNa z4<`fYiQdP+dunU|Y#Ro;|q^0pZAzNFHa literal 0 HcmV?d00001 diff --git a/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$3.class b/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$3.class new file mode 100644 index 0000000000000000000000000000000000000000..e74393ef5ed67f14e52d3a907c975ede1a79c60d GIT binary patch literal 1610 zcma)6TW=dh6#kCAjvagJl%-Bu+NN#@!Exel8zbq9!EhQ`6*;H`{dfv?mdR{A3@lr(H@D4|!=(3w-IdWs zL_cz)XEy@QPnapKKQeX=-S63Y z282x8@Y_pnlLK?TYZ+W1q~@v%x8|kqsERRMA~{D1(>! zUN;vqxDsEh8H~r*xeSVg%e#H({G!QCkK#30DSSgpSn<#R)X#2-gP|AG@BgT266Cd~(8Uo-pc!wq4vc zY>r_$thd9CBLQ6`j87B?K^!-zM5fPRCn)_dKeBE)Vl(XU=sz^JZ3b0acTL0IGCWK2 zu}}%x7SBL={dv)>5yqNs{5Fn17|zWD%$dgiXPS95*&v>I?KH52bF4IXHjHjuUUu*l z{4|yc*Pcy#zqeJ_>lnenisz`|hMp-_Em=t6-09Mg8?G;D~V?Kaa`BTPLX z1O#=>afG*I8@?}m6jA1Xj$HEOzYYkm@l9t+Qd0gI^kbxcolmI-_3#GY)xH7VM2$HG zw^@>q&QxbE#j>X}zaYIa`vfW4pWRF>DwPAA`+*g_1aBqr*H@!VKV&+_w9fPr(;8D* z#B4=-@c@NyP)#l>-=R{`E=BC5BH8hZb~$1TDanphw5t(2G_u z^OkX!%i1;V`pf}dKEU*TS<{a)w~jJZZQ;<2_SrKDiNX|yxyyjt3NcK($k86Yrcd!L zeTJXtb3CRm@F#s4p;U~rKaEjhOz;-&FmfsUj<@j+Bla#wyolW2$fc402lISVKA+Ex gtGw_YYZbO%;y5dOPhb^yBiTJZ>%6n9m7VeW4@L``A^-pY literal 0 HcmV?d00001 diff --git a/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$4.class b/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$4.class new file mode 100644 index 0000000000000000000000000000000000000000..e10c3a7283c6238b854bcae547db81773327d302 GIT binary patch literal 824 zcma)4-EPw`7(HKG+Aa&Ml>P9(3RP3v34%nq8rlUNph_KF6!qRqOzM$1!EuoGR&ark zxZnYJ7$jZ*@g=PUMViz|jz8Py9G_$R$M0|70SwXEKn2wXYA&vzPUs~j^ycbJ8ZE5! z0wp5pTklOO^(&EQ*~wy}J0#TYTxH$I%$cl5I&#p&MgxwEO}K<7tF-xt$jegYslXct zZ^c<8r+Jzt#!ju!fiS^1P9xs-nbOK06RN%btch!cUEfGH+p#icxG)zTTd)a-Ydh=D z2(?iXFllR|w0xb%d<3NlLVJ?K8teL$#JR<{9 literal 0 HcmV?d00001 diff --git a/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect.class b/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect.class new file mode 100644 index 0000000000000000000000000000000000000000..1ea099d943d6a16d8b0634e8dee4bb1c5d7580d2 GIT binary patch literal 15104 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 literal 0 HcmV?d00001 diff --git a/openGaussDialect/target/classes/org/hibernate/dialect/function/SubstringFunction.class b/openGaussDialect/target/classes/org/hibernate/dialect/function/SubstringFunction.class new file mode 100644 index 0000000000000000000000000000000000000000..b61cdda225e759ec6d1377098e2be1caaa333179 GIT binary patch literal 1973 zcmbVNU2_vv7=BJZx@p)_D5Y3IyMSm?TNbd2vWQTmH5v+SI-SA0ZE}(>CcAMz80(Ec zrThRd(2I7E8NKH(Ipg@8-DFA93XB&yXW#d{AJ6-q=RJA(&mVsRSVFCc46+(>I`SA3 zIPutiVw-K-ZJ7_YAIo|uFm}^%o$!`Gwp894M*-s+iaL%#7r5m4Epx}&mcDC;(hPUI z(yWEH+pzt{vK=_}O=<$hsBLak)>Z}Psz-YGj@weE)-fE%q=pkZPGU;ncnl{BowiwZ z0)oi}&d)N2QqeFiaOM@>TBxEdM^3vT{US~wTfiBCVi0Wy@li=BXLY=bvqWTfyV7k4 zES9RHF|6_-RWEFe?>!ywV~!wNl88>1Dud=p*DRIlyh?RpBt!3f&}9g?Rlo;CXEc4U zV-)bAK;CG2K0iwWqO9W1>-ZQ80)@~^Tm_~}hXYy~E(@F+?)Q2m{oQ*%)nzwyJhy-= z0!tP5iQRS@h8uNwk%reaY`+zCq#Fit>a>AIGji+7?}njpTvPRZ!W6?D7%r!XMSQBr z^_gnbp}tz>Ee)RwTp5PhaO^h8XZ91Cwf-fp^dM-sAu#_Yuk~u*p47SPHAtPws^iMF zxYSL1yG_kh)vMd>E!%gL+*9Vl9f!odHp1681G5D59Xq(wZ(&TBeI3BHdL`Dvz+hRdx&~?oF}%|`P7+k$!id!oi8*a4x75_LTF#=tkFTj_c*3p!PEwOWK<=&B_0aQoE1hmz zDvo;o5#!2B7*9#eS1sXP`i}5eYbJ5X|NoOxV1n;l{Rg(ZN0?&Gi~PD=aTKLy4)OJ} zsuSmNo$sx{7kqs4-1+8mwJ4d~h0@L+K>Ws!3~q8&$KYH0C09K$z%6`5N#Hi_a8=F= z+?8D>_p4e5JSPV{GpXnDTX;?%>3J7lGrr2X%#2y?x!<8Z8_7Bw`x?o4FDor^4=XXw z99HoS<5ZMCHH-Xxi|>-iB1>J4CwmLeF+mnR#qAe3_2>Ynr)Ku?&O-J%&SkI`8|fr-&nmq)S7kbGuZeSmfi3k literal 0 HcmV?d00001 diff --git a/openGaussDialect/target/classes/org/hibernate/dialect/identity/OpenGaussIdentityColumnSupport.class b/openGaussDialect/target/classes/org/hibernate/dialect/identity/OpenGaussIdentityColumnSupport.class new file mode 100644 index 0000000000000000000000000000000000000000..f26ba16b6a6bc8dd8260e412d570798c7895b8d0 GIT binary patch literal 1316 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 literal 0 HcmV?d00001 diff --git a/openGaussDialect/target/test-classes/org/hibernate/dialect/entity/function/TestEntity.class b/openGaussDialect/target/test-classes/org/hibernate/dialect/entity/function/TestEntity.class new file mode 100644 index 0000000000000000000000000000000000000000..ae7186320cba4064ddf64197dec176f5de5b5b2c GIT binary patch literal 2533 zcmb7FQBxaL6#j0qn}o0sNP&`qN(e0{!VW z(|cPF8ABoSKpOXG=tYv4+lEu5<77J1X6m|*qYwR23}`qnVS7#@^N<80hICVxcqt7R zFhu9X+wj8d3qZC4?ZZnNUdAi5t?2d2ZM)2r!s$#gii-m0PrR%-HPhO@)iA4NqZY>q zMm3D#GTqLYmg&s7Z*9cznn3pnk!iC$D~&T6vKXhazPoE!%y6=u3lF={o^!w*2_3 z|5tl@THoI_qma)>UDB%?dd-xwuT-3h$!M=G z{oiSz(;+|oqP2Gh0m-GRy|ZOM%C(Z?D{9^A<#X+oc3U~KA+v6EW?(G*#*`+)4i1-J zYa-iD#i$8HWkO?eP-Cvf-Ns#|KbxJN-j}-89KG~tS>N>uQSYx7mlx=$$i}Q0^+wfU z7rQ8tG5?**&qd$XYHh*B*X%~EWZW?&{fUzSxFRP=;KCW5;9WIjDs{%88zRpXOWz@4 z+~M8ynIo%-iyZJi-g6=T@p^;6+mw1KUFVvoTre<$St@u@Q5C0(*9+x2N;yh`tD5~D z;#+P)xWT8yktpx*sd)ytiCdIz^Ix9Mb7dwNIs+(r8YuZfpatCVf%05K(n)swF~oP= zwTIN{A`N&Jen>JPFZEz>i?~ZWnPmVo`d=|6U*c54yl#EWKe$GTT^Y}Q164U3{{^A1 zp@t8~e@19|BHKi#D{_-qncyR@O#X__l=2k42hb){N)zXfEe7){O$PIklqzi^Pmw%8 zS4vGqj*XN<`UP8DBDhcd5p+ajf1*2z&@&7~(Z^p*Jj0;3?Fh1=$Zwj@#&!CXRZ}GmGSq)6n%W9g zWq>l&VA1&X@gaZbsuC&RQlr^lbh3%z&!v7augHUx;-ADMwLBU= zo3d#S)sG{LYj_{4j6>xoV2!&F%RYs5#ummXzpo!~r?~WRJ)%M(JwlKY2ysNC6PfBG zQm-Bx9NQ>C70pg%&5w_twe&A%Fa0A%HlN^9^3^8NGWjMZk~wcbDEF^(-^3fIN6l*s zZ)VeejzNa`o%Vg54F3~cJ3STJ3ukr=8$Qr7*D!-lWC`TXZFb@@o*T3-7jnciZS_Hd i%zO7u!o8wG0d7M0(Cwy=+D(({gtUkGA*h9bX{6;<%1~Qy`YfZjHdeh>nDbQJ4brUTe3|aJKE1 zYx#De?pRI66b`&Sudrda+MX+*ICX)Gl@s8y>)X3_t0b|;O-x`?Ky|HsTOirzR`Xkq zyIV@oD{0~)rUZ-~%U%1nV>Jb)GkvZh)l&9r={#d%7MBFHUE447=;=(h&$V~B%=--! zmnCf6mY8iB{HBSw@V0=?;Prsg)Ij(#DFyQ;-oX`;YFO>Y9j{LMRH&@uU4hw?Y{Q7# z9j95hTL~;6W*{Sw2<6E*^;K!inaE?2RIGyo+a>Fz{`{g-`|}uprAQ07Dj^C(kv(Pl z6c~&&@By=3oRj*m8u&;+WF^{l6CX<<4Bra_bbKl>73Af3g__;sT|3`d+fC-JhUrgK z9M@j&?6Vvmha1U?w_`Q8EIQLMGOB*VX$xGboLf94fy+Qw$Ny2fM5ERL4l z?ljqwu>eC`h~jHrr?q3>bL3TwhIMsSUKHk8(Fz1U;aia%%br(c!*NW|&X(u;23G~H z1V=6R9O9?It;lygFpi+axfwcO1*=@$jCMccD1knYfT|p0v`t8$T>csK+~PBg4MQdZ z$hpupf@Dy@QSz7wSSmxuu&+z#)g5$&jq@L+YwNaqe3F_ zAnDCC|(#3d6lRohmNFHJ= zrKRFMC-sPD#riHMWc?uIaI8cFYq&?&)2QJ-3ryiB=q?`67DJA?lsQwmGmnRyX{hqc z{RL-nRER&vf0FSJ#&sC4Fr!1^V~AI{6i!D5)llWnBvRuB&y=^ONf{*7{yORxSUaYw zk%pu?cxn6T8aBu+MlQ4Xk~1}s=ONVBG^mtE2ucDWUeoDhtw_T( zw4OuHM;$cLZ76I0BBHD}B`mYf{ECIIp5wjb`(0#Z@?9(?uZ8n8hvbKRb+J6$YN6KQ QHzpJ1IH>Sua67gC00OIfCIA2c literal 0 HcmV?d00001 diff --git a/openGaussDialect/target/test-classes/org/hibernate/dialect/unit/OpenGaussFunctionTest.class b/openGaussDialect/target/test-classes/org/hibernate/dialect/unit/OpenGaussFunctionTest.class new file mode 100644 index 0000000000000000000000000000000000000000..241a282a5e409228dd5e6d96f848624452137a49 GIT binary patch literal 15782 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 HLLB&iHL6{& literal 0 HcmV?d00001