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 00000000..b0576bd0 Binary files /dev/null and b/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$1.class differ 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 00000000..5b33d464 Binary files /dev/null and b/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$2.class differ 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 00000000..e74393ef Binary files /dev/null and b/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$3.class differ 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 00000000..e10c3a72 Binary files /dev/null and b/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect$4.class differ 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 00000000..1ea099d9 Binary files /dev/null and b/openGaussDialect/target/classes/org/hibernate/dialect/OpenGaussDialect.class differ 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 00000000..b61cdda2 Binary files /dev/null and b/openGaussDialect/target/classes/org/hibernate/dialect/function/SubstringFunction.class differ 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 00000000..f26ba16b Binary files /dev/null and b/openGaussDialect/target/classes/org/hibernate/dialect/identity/OpenGaussIdentityColumnSupport.class differ diff --git a/openGaussDialect/target/classes/org/hibernate/dialect/type/JsonType.class b/openGaussDialect/target/classes/org/hibernate/dialect/type/JsonType.class new file mode 100644 index 00000000..02d3f1ef Binary files /dev/null and b/openGaussDialect/target/classes/org/hibernate/dialect/type/JsonType.class differ diff --git a/openGaussDialect/target/classes/org/hibernate/dialect/type/JsonbType.class b/openGaussDialect/target/classes/org/hibernate/dialect/type/JsonbType.class new file mode 100644 index 00000000..fd4aa96f Binary files /dev/null and b/openGaussDialect/target/classes/org/hibernate/dialect/type/JsonbType.class differ 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 00000000..ae718632 Binary files /dev/null and b/openGaussDialect/target/test-classes/org/hibernate/dialect/entity/function/TestEntity.class differ diff --git a/openGaussDialect/target/test-classes/org/hibernate/dialect/pojo/Person.class b/openGaussDialect/target/test-classes/org/hibernate/dialect/pojo/Person.class new file mode 100644 index 00000000..19280985 Binary files /dev/null and b/openGaussDialect/target/test-classes/org/hibernate/dialect/pojo/Person.class differ 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 00000000..241a282a Binary files /dev/null and b/openGaussDialect/target/test-classes/org/hibernate/dialect/unit/OpenGaussFunctionTest.class differ