diff --git a/hibernate-types-4/pom.xml b/hibernate-types-4/pom.xml index ed2947eb8..a26e67856 100644 --- a/hibernate-types-4/pom.xml +++ b/hibernate-types-4/pom.xml @@ -47,15 +47,6 @@ true - - org.javamoney - moneta - ${moneta.version} - pom - provided - true - - org.hibernate hibernate-ehcache @@ -79,7 +70,6 @@ 2.12.6.1 12.0 - 1.4.2 diff --git a/hibernate-types-43/pom.xml b/hibernate-types-43/pom.xml index ae508bfd9..f787a7b52 100644 --- a/hibernate-types-43/pom.xml +++ b/hibernate-types-43/pom.xml @@ -47,15 +47,6 @@ true - - org.javamoney - moneta - ${moneta.version} - pom - provided - true - - org.hibernate hibernate-ehcache @@ -79,7 +70,6 @@ 2.12.6.1 12.0 - 1.4.2 diff --git a/hibernate-types-5/pom.xml b/hibernate-types-5/pom.xml index c388c0917..b66b2e691 100644 --- a/hibernate-types-5/pom.xml +++ b/hibernate-types-5/pom.xml @@ -47,15 +47,6 @@ true - - org.javamoney - moneta - ${moneta.version} - pom - provided - true - - org.hibernate hibernate-ehcache @@ -79,7 +70,6 @@ 2.12.6.1 12.0 - 1.4.2 diff --git a/hibernate-types-52/src/main/java/com/vladmihalcea/hibernate/type/HibernateTypesContributor.java b/hibernate-types-52/src/main/java/com/vladmihalcea/hibernate/type/HibernateTypesContributor.java index 3a405971c..f0209cd9d 100644 --- a/hibernate-types-52/src/main/java/com/vladmihalcea/hibernate/type/HibernateTypesContributor.java +++ b/hibernate-types-52/src/main/java/com/vladmihalcea/hibernate/type/HibernateTypesContributor.java @@ -6,6 +6,7 @@ import com.vladmihalcea.hibernate.type.interval.PostgreSQLIntervalType; import com.vladmihalcea.hibernate.type.interval.PostgreSQLPeriodType; import com.vladmihalcea.hibernate.type.json.*; +import com.vladmihalcea.hibernate.type.money.CurrencyUnitType; import com.vladmihalcea.hibernate.type.money.MonetaryAmountType; import com.vladmihalcea.hibernate.type.range.PostgreSQLRangeType; import com.vladmihalcea.hibernate.type.range.guava.PostgreSQLGuavaRangeType; @@ -98,7 +99,8 @@ public void contribute(TypeContributions typeContributions, ServiceRegistry serv .contributeType(typeContributions, JsonType.INSTANCE); /* Money and Currency API */ if(ReflectionUtils.getClassOrNull("org.javamoney.moneta.Money") != null) { - this.contributeType(typeContributions, MonetaryAmountType.INSTANCE); + this.contributeType(typeContributions, CurrencyUnitType.INSTANCE) + .contributeType(typeContributions, MonetaryAmountType.INSTANCE); } } diff --git a/hibernate-types-52/src/main/java/com/vladmihalcea/hibernate/type/money/CurrencyUnitType.java b/hibernate-types-52/src/main/java/com/vladmihalcea/hibernate/type/money/CurrencyUnitType.java new file mode 100644 index 000000000..6c0735b42 --- /dev/null +++ b/hibernate-types-52/src/main/java/com/vladmihalcea/hibernate/type/money/CurrencyUnitType.java @@ -0,0 +1,39 @@ +package com.vladmihalcea.hibernate.type.money; + +import com.vladmihalcea.hibernate.type.AbstractHibernateType; +import com.vladmihalcea.hibernate.type.money.internal.CurrencyUnitTypeDescriptor; +import com.vladmihalcea.hibernate.type.util.Configuration; +import org.hibernate.type.descriptor.sql.VarcharTypeDescriptor; + +import javax.money.CurrencyUnit; + +/** + * Maps a Java {@link CurrencyUnit} object to a {@code VARCHAR} column type. + * + * @author Piotr Olaszewski + */ +public class CurrencyUnitType extends AbstractHibernateType { + public static final CurrencyUnitType INSTANCE = new CurrencyUnitType(); + + public CurrencyUnitType() { + super(VarcharTypeDescriptor.INSTANCE, CurrencyUnitTypeDescriptor.INSTANCE); + } + + public CurrencyUnitType(Configuration configuration) { + super( + VarcharTypeDescriptor.INSTANCE, + CurrencyUnitTypeDescriptor.INSTANCE, + configuration + ); + } + + @Override + public String getName() { + return "currency"; + } + + @Override + protected boolean registerUnderJavaType() { + return true; + } +} diff --git a/hibernate-types-52/src/main/java/com/vladmihalcea/hibernate/type/money/internal/CurrencyUnitTypeDescriptor.java b/hibernate-types-52/src/main/java/com/vladmihalcea/hibernate/type/money/internal/CurrencyUnitTypeDescriptor.java new file mode 100644 index 000000000..ad9e63459 --- /dev/null +++ b/hibernate-types-52/src/main/java/com/vladmihalcea/hibernate/type/money/internal/CurrencyUnitTypeDescriptor.java @@ -0,0 +1,50 @@ +package com.vladmihalcea.hibernate.type.money.internal; + +import org.hibernate.type.descriptor.WrapperOptions; +import org.hibernate.type.descriptor.java.AbstractTypeDescriptor; + +import javax.money.CurrencyUnit; +import javax.money.Monetary; + +/** + * @author Piotr Olaszewski + */ +public class CurrencyUnitTypeDescriptor extends AbstractTypeDescriptor { + + public static final CurrencyUnitTypeDescriptor INSTANCE = new CurrencyUnitTypeDescriptor(); + + public CurrencyUnitTypeDescriptor() { + super(CurrencyUnit.class); + } + + @Override + public CurrencyUnit fromString(String string) { + return Monetary.getCurrency(string); + } + + @Override + public X unwrap(CurrencyUnit value, Class type, WrapperOptions options) { + if (value == null) { + return null; + } + + if (String.class.isAssignableFrom(type)) { + return (X) value.getCurrencyCode(); + } + + throw unknownUnwrap(type); + } + + @Override + public CurrencyUnit wrap(X value, WrapperOptions options) { + if (value == null) { + return null; + } + + if (value instanceof String) { + return fromString((String) value); + } + + throw unknownWrap(value.getClass()); + } +} diff --git a/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLCurrencyUnitTypeTest.java b/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLCurrencyUnitTypeTest.java new file mode 100644 index 000000000..5e77ba541 --- /dev/null +++ b/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLCurrencyUnitTypeTest.java @@ -0,0 +1,118 @@ +package com.vladmihalcea.hibernate.type.money; + +import com.vladmihalcea.hibernate.util.AbstractMySQLIntegrationTest; +import org.hibernate.annotations.TypeDef; +import org.junit.Test; + +import javax.money.CurrencyUnit; +import javax.persistence.*; + +import static javax.money.Monetary.getCurrency; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +/** + * @author Piotr Olaszewski + */ +public class MySQLCurrencyUnitTypeTest extends AbstractMySQLIntegrationTest { + @Override + protected Class[] entities() { + return new Class[]{ + Order.class + }; + } + + @Test + public void testPersistAndReadCurrency() { + Order _order = doInJPA(entityManager -> { + Order order = new Order(); + order.setCurrency(getCurrency("EUR")); + + entityManager.persist(order); + + return order; + }); + + doInJPA(entityManager -> { + Order order = entityManager.find(Order.class, _order.getId()); + + assertEquals(order.getCurrency(), getCurrency("EUR")); + }); + } + + @Test + public void testSearchByCurrency() { + doInJPA(entityManager -> { + Order order1 = new Order(); + order1.setCurrency(getCurrency("EUR")); + entityManager.persist(order1); + + Order order2 = new Order(); + order2.setCurrency(getCurrency("PLN")); + entityManager.persist(order2); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = getCurrency("PLN"); + Order order = entityManager.createQuery("select o from Order o where o.currency = :currency", Order.class) + .setParameter("currency", currency) + .getSingleResult(); + + assertEquals(Long.valueOf(2), order.getId()); + }); + } + + @Test + public void testReturnNullCurrency() { + Long _id = doInJPA(entityManager -> { + Order order = new Order(); + entityManager.persist(order); + + return order.getId(); + }); + + doInJPA(entityManager -> { + Order order = entityManager.createQuery("select o from Order o where o.id = :id", Order.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(order.getCurrency()); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = entityManager.createQuery("select o.currency from Order o where o.id = :id", CurrencyUnit.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(currency); + }); + } + + @Entity(name = "Order") + @Table(name = "orders") + @TypeDef(typeClass = CurrencyUnitType.class, defaultForType = CurrencyUnit.class) + public static class Order { + @Id + @GeneratedValue + private Long id; + + @Column(name = "currency", columnDefinition = "char(3)") + private CurrencyUnit currency; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public CurrencyUnit getCurrency() { + return currency; + } + + public void setCurrency(CurrencyUnit currency) { + this.currency = currency; + } + } +} diff --git a/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java b/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java index c6ea0cd2b..38230dda4 100644 --- a/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java +++ b/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java @@ -57,7 +57,7 @@ public void testSearchByMoney() { doInJPA(entityManager -> { Money money = Money.of(new BigDecimal("10.23"), "USD"); - Salary salary = entityManager.createQuery("select s from Salary s where salary = :salary", Salary.class) + Salary salary = entityManager.createQuery("select s from Salary s where s.salary = :salary", Salary.class) .setParameter("salary", money) .getSingleResult(); diff --git a/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLCurrencyUnitTypeTest.java b/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLCurrencyUnitTypeTest.java new file mode 100644 index 000000000..dc4fa0d1a --- /dev/null +++ b/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLCurrencyUnitTypeTest.java @@ -0,0 +1,118 @@ +package com.vladmihalcea.hibernate.type.money; + +import com.vladmihalcea.hibernate.util.AbstractPostgreSQLIntegrationTest; +import org.hibernate.annotations.TypeDef; +import org.junit.Test; + +import javax.money.CurrencyUnit; +import javax.persistence.*; + +import static javax.money.Monetary.getCurrency; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +/** + * @author Piotr Olaszewski + */ +public class PostgreSQLCurrencyUnitTypeTest extends AbstractPostgreSQLIntegrationTest { + @Override + protected Class[] entities() { + return new Class[]{ + Order.class + }; + } + + @Test + public void testPersistAndReadCurrency() { + Order _order = doInJPA(entityManager -> { + Order order = new Order(); + order.setCurrency(getCurrency("EUR")); + + entityManager.persist(order); + + return order; + }); + + doInJPA(entityManager -> { + Order order = entityManager.find(Order.class, _order.getId()); + + assertEquals(order.getCurrency(), getCurrency("EUR")); + }); + } + + @Test + public void testSearchByCurrency() { + doInJPA(entityManager -> { + Order order1 = new Order(); + order1.setCurrency(getCurrency("EUR")); + entityManager.persist(order1); + + Order order2 = new Order(); + order2.setCurrency(getCurrency("PLN")); + entityManager.persist(order2); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = getCurrency("PLN"); + Order order = entityManager.createQuery("select o from Order o where o.currency = :currency", Order.class) + .setParameter("currency", currency) + .getSingleResult(); + + assertEquals(Long.valueOf(2), order.getId()); + }); + } + + @Test + public void testReturnNullCurrency() { + Long _id = doInJPA(entityManager -> { + Order order = new Order(); + entityManager.persist(order); + + return order.getId(); + }); + + doInJPA(entityManager -> { + Order order = entityManager.createQuery("select o from Order o where o.id = :id", Order.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(order.getCurrency()); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = entityManager.createQuery("select o.currency from Order o where o.id = :id", CurrencyUnit.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(currency); + }); + } + + @Entity(name = "Order") + @Table(name = "orders") + @TypeDef(typeClass = CurrencyUnitType.class, defaultForType = CurrencyUnit.class) + public static class Order { + @Id + @GeneratedValue + private Long id; + + @Column(name = "currency", columnDefinition = "char(3)") + private CurrencyUnit currency; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public CurrencyUnit getCurrency() { + return currency; + } + + public void setCurrency(CurrencyUnit currency) { + this.currency = currency; + } + } +} diff --git a/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java b/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java index 784823073..002c83abb 100644 --- a/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java +++ b/hibernate-types-52/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java @@ -57,7 +57,7 @@ public void testSearchByMoney() { doInJPA(entityManager -> { Money money = Money.of(new BigDecimal("10.23"), "USD"); - Salary salary = entityManager.createQuery("select s from Salary s where salary = :salary", Salary.class) + Salary salary = entityManager.createQuery("select s from Salary s where s.salary = :salary", Salary.class) .setParameter("salary", money) .getSingleResult(); diff --git a/hibernate-types-55/src/main/java/com/vladmihalcea/hibernate/type/HibernateTypesContributor.java b/hibernate-types-55/src/main/java/com/vladmihalcea/hibernate/type/HibernateTypesContributor.java index 3a405971c..f0209cd9d 100644 --- a/hibernate-types-55/src/main/java/com/vladmihalcea/hibernate/type/HibernateTypesContributor.java +++ b/hibernate-types-55/src/main/java/com/vladmihalcea/hibernate/type/HibernateTypesContributor.java @@ -6,6 +6,7 @@ import com.vladmihalcea.hibernate.type.interval.PostgreSQLIntervalType; import com.vladmihalcea.hibernate.type.interval.PostgreSQLPeriodType; import com.vladmihalcea.hibernate.type.json.*; +import com.vladmihalcea.hibernate.type.money.CurrencyUnitType; import com.vladmihalcea.hibernate.type.money.MonetaryAmountType; import com.vladmihalcea.hibernate.type.range.PostgreSQLRangeType; import com.vladmihalcea.hibernate.type.range.guava.PostgreSQLGuavaRangeType; @@ -98,7 +99,8 @@ public void contribute(TypeContributions typeContributions, ServiceRegistry serv .contributeType(typeContributions, JsonType.INSTANCE); /* Money and Currency API */ if(ReflectionUtils.getClassOrNull("org.javamoney.moneta.Money") != null) { - this.contributeType(typeContributions, MonetaryAmountType.INSTANCE); + this.contributeType(typeContributions, CurrencyUnitType.INSTANCE) + .contributeType(typeContributions, MonetaryAmountType.INSTANCE); } } diff --git a/hibernate-types-55/src/main/java/com/vladmihalcea/hibernate/type/money/CurrencyUnitType.java b/hibernate-types-55/src/main/java/com/vladmihalcea/hibernate/type/money/CurrencyUnitType.java new file mode 100644 index 000000000..d9f67a9c0 --- /dev/null +++ b/hibernate-types-55/src/main/java/com/vladmihalcea/hibernate/type/money/CurrencyUnitType.java @@ -0,0 +1,44 @@ +package com.vladmihalcea.hibernate.type.money; + +import com.vladmihalcea.hibernate.type.AbstractHibernateType; +import com.vladmihalcea.hibernate.type.money.internal.CurrencyUnitTypeDescriptor; +import com.vladmihalcea.hibernate.type.util.Configuration; +import org.hibernate.type.descriptor.sql.VarcharTypeDescriptor; +import org.hibernate.type.spi.TypeBootstrapContext; + +import javax.money.CurrencyUnit; + +/** + * Maps a Java {@link CurrencyUnit} object to a {@code VARCHAR} column type. + * + * @author Piotr Olaszewski + */ +public class CurrencyUnitType extends AbstractHibernateType { + public static final CurrencyUnitType INSTANCE = new CurrencyUnitType(); + + public CurrencyUnitType() { + super(VarcharTypeDescriptor.INSTANCE, CurrencyUnitTypeDescriptor.INSTANCE); + } + + public CurrencyUnitType(Configuration configuration) { + super( + VarcharTypeDescriptor.INSTANCE, + CurrencyUnitTypeDescriptor.INSTANCE, + configuration + ); + } + + public CurrencyUnitType(TypeBootstrapContext typeBootstrapContext) { + this(new Configuration(typeBootstrapContext.getConfigurationSettings())); + } + + @Override + public String getName() { + return "currency"; + } + + @Override + protected boolean registerUnderJavaType() { + return true; + } +} diff --git a/hibernate-types-55/src/main/java/com/vladmihalcea/hibernate/type/money/internal/CurrencyUnitTypeDescriptor.java b/hibernate-types-55/src/main/java/com/vladmihalcea/hibernate/type/money/internal/CurrencyUnitTypeDescriptor.java new file mode 100644 index 000000000..ad9e63459 --- /dev/null +++ b/hibernate-types-55/src/main/java/com/vladmihalcea/hibernate/type/money/internal/CurrencyUnitTypeDescriptor.java @@ -0,0 +1,50 @@ +package com.vladmihalcea.hibernate.type.money.internal; + +import org.hibernate.type.descriptor.WrapperOptions; +import org.hibernate.type.descriptor.java.AbstractTypeDescriptor; + +import javax.money.CurrencyUnit; +import javax.money.Monetary; + +/** + * @author Piotr Olaszewski + */ +public class CurrencyUnitTypeDescriptor extends AbstractTypeDescriptor { + + public static final CurrencyUnitTypeDescriptor INSTANCE = new CurrencyUnitTypeDescriptor(); + + public CurrencyUnitTypeDescriptor() { + super(CurrencyUnit.class); + } + + @Override + public CurrencyUnit fromString(String string) { + return Monetary.getCurrency(string); + } + + @Override + public X unwrap(CurrencyUnit value, Class type, WrapperOptions options) { + if (value == null) { + return null; + } + + if (String.class.isAssignableFrom(type)) { + return (X) value.getCurrencyCode(); + } + + throw unknownUnwrap(type); + } + + @Override + public CurrencyUnit wrap(X value, WrapperOptions options) { + if (value == null) { + return null; + } + + if (value instanceof String) { + return fromString((String) value); + } + + throw unknownWrap(value.getClass()); + } +} diff --git a/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLCurrencyUnitTypeTest.java b/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLCurrencyUnitTypeTest.java new file mode 100644 index 000000000..5e77ba541 --- /dev/null +++ b/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLCurrencyUnitTypeTest.java @@ -0,0 +1,118 @@ +package com.vladmihalcea.hibernate.type.money; + +import com.vladmihalcea.hibernate.util.AbstractMySQLIntegrationTest; +import org.hibernate.annotations.TypeDef; +import org.junit.Test; + +import javax.money.CurrencyUnit; +import javax.persistence.*; + +import static javax.money.Monetary.getCurrency; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +/** + * @author Piotr Olaszewski + */ +public class MySQLCurrencyUnitTypeTest extends AbstractMySQLIntegrationTest { + @Override + protected Class[] entities() { + return new Class[]{ + Order.class + }; + } + + @Test + public void testPersistAndReadCurrency() { + Order _order = doInJPA(entityManager -> { + Order order = new Order(); + order.setCurrency(getCurrency("EUR")); + + entityManager.persist(order); + + return order; + }); + + doInJPA(entityManager -> { + Order order = entityManager.find(Order.class, _order.getId()); + + assertEquals(order.getCurrency(), getCurrency("EUR")); + }); + } + + @Test + public void testSearchByCurrency() { + doInJPA(entityManager -> { + Order order1 = new Order(); + order1.setCurrency(getCurrency("EUR")); + entityManager.persist(order1); + + Order order2 = new Order(); + order2.setCurrency(getCurrency("PLN")); + entityManager.persist(order2); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = getCurrency("PLN"); + Order order = entityManager.createQuery("select o from Order o where o.currency = :currency", Order.class) + .setParameter("currency", currency) + .getSingleResult(); + + assertEquals(Long.valueOf(2), order.getId()); + }); + } + + @Test + public void testReturnNullCurrency() { + Long _id = doInJPA(entityManager -> { + Order order = new Order(); + entityManager.persist(order); + + return order.getId(); + }); + + doInJPA(entityManager -> { + Order order = entityManager.createQuery("select o from Order o where o.id = :id", Order.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(order.getCurrency()); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = entityManager.createQuery("select o.currency from Order o where o.id = :id", CurrencyUnit.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(currency); + }); + } + + @Entity(name = "Order") + @Table(name = "orders") + @TypeDef(typeClass = CurrencyUnitType.class, defaultForType = CurrencyUnit.class) + public static class Order { + @Id + @GeneratedValue + private Long id; + + @Column(name = "currency", columnDefinition = "char(3)") + private CurrencyUnit currency; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public CurrencyUnit getCurrency() { + return currency; + } + + public void setCurrency(CurrencyUnit currency) { + this.currency = currency; + } + } +} diff --git a/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java b/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java index b9f0a18d1..2b4bad4bc 100644 --- a/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java +++ b/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java @@ -58,7 +58,7 @@ public void testSearchByMoney() { doInJPA(entityManager -> { Money money = Money.of(new BigDecimal("10.23"), "USD"); - Salary salary = entityManager.createQuery("select s from Salary s where salary = :salary", Salary.class) + Salary salary = entityManager.createQuery("select s from Salary s where s.salary = :salary", Salary.class) .setParameter("salary", money) .getSingleResult(); diff --git a/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLCurrencyUnitTypeTest.java b/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLCurrencyUnitTypeTest.java new file mode 100644 index 000000000..dc4fa0d1a --- /dev/null +++ b/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLCurrencyUnitTypeTest.java @@ -0,0 +1,118 @@ +package com.vladmihalcea.hibernate.type.money; + +import com.vladmihalcea.hibernate.util.AbstractPostgreSQLIntegrationTest; +import org.hibernate.annotations.TypeDef; +import org.junit.Test; + +import javax.money.CurrencyUnit; +import javax.persistence.*; + +import static javax.money.Monetary.getCurrency; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +/** + * @author Piotr Olaszewski + */ +public class PostgreSQLCurrencyUnitTypeTest extends AbstractPostgreSQLIntegrationTest { + @Override + protected Class[] entities() { + return new Class[]{ + Order.class + }; + } + + @Test + public void testPersistAndReadCurrency() { + Order _order = doInJPA(entityManager -> { + Order order = new Order(); + order.setCurrency(getCurrency("EUR")); + + entityManager.persist(order); + + return order; + }); + + doInJPA(entityManager -> { + Order order = entityManager.find(Order.class, _order.getId()); + + assertEquals(order.getCurrency(), getCurrency("EUR")); + }); + } + + @Test + public void testSearchByCurrency() { + doInJPA(entityManager -> { + Order order1 = new Order(); + order1.setCurrency(getCurrency("EUR")); + entityManager.persist(order1); + + Order order2 = new Order(); + order2.setCurrency(getCurrency("PLN")); + entityManager.persist(order2); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = getCurrency("PLN"); + Order order = entityManager.createQuery("select o from Order o where o.currency = :currency", Order.class) + .setParameter("currency", currency) + .getSingleResult(); + + assertEquals(Long.valueOf(2), order.getId()); + }); + } + + @Test + public void testReturnNullCurrency() { + Long _id = doInJPA(entityManager -> { + Order order = new Order(); + entityManager.persist(order); + + return order.getId(); + }); + + doInJPA(entityManager -> { + Order order = entityManager.createQuery("select o from Order o where o.id = :id", Order.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(order.getCurrency()); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = entityManager.createQuery("select o.currency from Order o where o.id = :id", CurrencyUnit.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(currency); + }); + } + + @Entity(name = "Order") + @Table(name = "orders") + @TypeDef(typeClass = CurrencyUnitType.class, defaultForType = CurrencyUnit.class) + public static class Order { + @Id + @GeneratedValue + private Long id; + + @Column(name = "currency", columnDefinition = "char(3)") + private CurrencyUnit currency; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public CurrencyUnit getCurrency() { + return currency; + } + + public void setCurrency(CurrencyUnit currency) { + this.currency = currency; + } + } +} diff --git a/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java b/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java index 784823073..002c83abb 100644 --- a/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java +++ b/hibernate-types-55/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java @@ -57,7 +57,7 @@ public void testSearchByMoney() { doInJPA(entityManager -> { Money money = Money.of(new BigDecimal("10.23"), "USD"); - Salary salary = entityManager.createQuery("select s from Salary s where salary = :salary", Salary.class) + Salary salary = entityManager.createQuery("select s from Salary s where s.salary = :salary", Salary.class) .setParameter("salary", money) .getSingleResult(); diff --git a/hibernate-types-60/src/main/java/com/vladmihalcea/hibernate/type/money/CurrencyUnitType.java b/hibernate-types-60/src/main/java/com/vladmihalcea/hibernate/type/money/CurrencyUnitType.java new file mode 100644 index 000000000..7f1e4734b --- /dev/null +++ b/hibernate-types-60/src/main/java/com/vladmihalcea/hibernate/type/money/CurrencyUnitType.java @@ -0,0 +1,18 @@ +package com.vladmihalcea.hibernate.type.money; + +import com.vladmihalcea.hibernate.type.MutableType; +import com.vladmihalcea.hibernate.type.money.internal.CurrencyUnitTypeDescriptor; +import org.hibernate.type.descriptor.jdbc.VarcharJdbcType; + +import javax.money.CurrencyUnit; + +/** + * Maps a Java {@link CurrencyUnit} object to a {@code VARCHAR} column type. + * + * @author Piotr Olaszewski + */ +public class CurrencyUnitType extends MutableType { + public CurrencyUnitType() { + super(CurrencyUnit.class, VarcharJdbcType.INSTANCE, CurrencyUnitTypeDescriptor.INSTANCE); + } +} diff --git a/hibernate-types-60/src/main/java/com/vladmihalcea/hibernate/type/money/internal/CurrencyUnitTypeDescriptor.java b/hibernate-types-60/src/main/java/com/vladmihalcea/hibernate/type/money/internal/CurrencyUnitTypeDescriptor.java new file mode 100644 index 000000000..d5435f370 --- /dev/null +++ b/hibernate-types-60/src/main/java/com/vladmihalcea/hibernate/type/money/internal/CurrencyUnitTypeDescriptor.java @@ -0,0 +1,46 @@ +package com.vladmihalcea.hibernate.type.money.internal; + +import org.hibernate.type.descriptor.WrapperOptions; +import org.hibernate.type.descriptor.java.AbstractClassJavaType; + +import javax.money.CurrencyUnit; + +import javax.money.Monetary; + +/** + * @author Piotr Olaszewski + */ +public class CurrencyUnitTypeDescriptor extends AbstractClassJavaType { + + public static final CurrencyUnitTypeDescriptor INSTANCE = new CurrencyUnitTypeDescriptor(); + + public CurrencyUnitTypeDescriptor() { + super(CurrencyUnit.class); + } + + @Override + public X unwrap(CurrencyUnit value, Class type, WrapperOptions options) { + if (value == null) { + return null; + } + + if (String.class.isAssignableFrom(type)) { + return (X) value.getCurrencyCode(); + } + + throw unknownUnwrap(type); + } + + @Override + public CurrencyUnit wrap(X value, WrapperOptions options) { + if (value == null) { + return null; + } + + if (value instanceof String) { + return Monetary.getCurrency((String) value); + } + + throw unknownWrap(value.getClass()); + } +} diff --git a/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLCurrencyUnitTypeTest.java b/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLCurrencyUnitTypeTest.java new file mode 100644 index 000000000..15844a471 --- /dev/null +++ b/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLCurrencyUnitTypeTest.java @@ -0,0 +1,118 @@ +package com.vladmihalcea.hibernate.type.money; + +import com.vladmihalcea.hibernate.util.AbstractMySQLIntegrationTest; +import jakarta.persistence.*; +import org.hibernate.annotations.Type; +import org.junit.Test; + +import javax.money.CurrencyUnit; + +import static javax.money.Monetary.getCurrency; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +/** + * @author Piotr Olaszewski + */ +public class MySQLCurrencyUnitTypeTest extends AbstractMySQLIntegrationTest { + @Override + protected Class[] entities() { + return new Class[]{ + Order.class + }; + } + + @Test + public void testPersistAndReadCurrency() { + Order _order = doInJPA(entityManager -> { + Order order = new Order(); + order.setCurrency(getCurrency("EUR")); + + entityManager.persist(order); + + return order; + }); + + doInJPA(entityManager -> { + Order order = entityManager.find(Order.class, _order.getId()); + + assertEquals(order.getCurrency(), getCurrency("EUR")); + }); + } + + @Test + public void testSearchByCurrency() { + doInJPA(entityManager -> { + Order order1 = new Order(); + order1.setCurrency(getCurrency("EUR")); + entityManager.persist(order1); + + Order order2 = new Order(); + order2.setCurrency(getCurrency("PLN")); + entityManager.persist(order2); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = getCurrency("PLN"); + Order order = entityManager.createQuery("select o from Order o where o.currency = :currency", Order.class) + .setParameter("currency", currency) + .getSingleResult(); + + assertEquals(Long.valueOf(2), order.getId()); + }); + } + + @Test + public void testReturnNullCurrency() { + Long _id = doInJPA(entityManager -> { + Order order = new Order(); + entityManager.persist(order); + + return order.getId(); + }); + + doInJPA(entityManager -> { + Order order = entityManager.createQuery("select o from Order o where o.id = :id", Order.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(order.getCurrency()); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = entityManager.createQuery("select o.currency from Order o where o.id = :id", CurrencyUnit.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(currency); + }); + } + + @Entity(name = "Order") + @Table(name = "orders") + public static class Order { + @Id + @GeneratedValue + private Long id; + + @Type(CurrencyUnitType.class) + @Column(name = "currency", columnDefinition = "char(3)") + private CurrencyUnit currency; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public CurrencyUnit getCurrency() { + return currency; + } + + public void setCurrency(CurrencyUnit currency) { + this.currency = currency; + } + } +} diff --git a/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java b/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java index f49a9b1c2..448a53bbb 100644 --- a/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java +++ b/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/MySQLMonetaryAmountTypeTest.java @@ -56,7 +56,7 @@ public void testSearchByMoney() { doInJPA(entityManager -> { Money money = Money.of(new BigDecimal("10.23"), "USD"); - Salary salary = entityManager.createQuery("select s from Salary s where salary = :salary", Salary.class) + Salary salary = entityManager.createQuery("select s from Salary s where s.salary = :salary", Salary.class) .setParameter("salary", money) .getSingleResult(); diff --git a/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLCurrencyUnitTypeTest.java b/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLCurrencyUnitTypeTest.java new file mode 100644 index 000000000..51781c940 --- /dev/null +++ b/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLCurrencyUnitTypeTest.java @@ -0,0 +1,118 @@ +package com.vladmihalcea.hibernate.type.money; + +import com.vladmihalcea.hibernate.util.AbstractPostgreSQLIntegrationTest; +import jakarta.persistence.*; +import org.hibernate.annotations.Type; +import org.junit.Test; + +import javax.money.CurrencyUnit; + +import static javax.money.Monetary.getCurrency; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +/** + * @author Piotr Olaszewski + */ +public class PostgreSQLCurrencyUnitTypeTest extends AbstractPostgreSQLIntegrationTest { + @Override + protected Class[] entities() { + return new Class[]{ + Order.class + }; + } + + @Test + public void testPersistAndReadCurrency() { + Order _order = doInJPA(entityManager -> { + Order order = new Order(); + order.setCurrency(getCurrency("EUR")); + + entityManager.persist(order); + + return order; + }); + + doInJPA(entityManager -> { + Order order = entityManager.find(Order.class, _order.getId()); + + assertEquals(order.getCurrency(), getCurrency("EUR")); + }); + } + + @Test + public void testSearchByCurrency() { + doInJPA(entityManager -> { + Order order1 = new Order(); + order1.setCurrency(getCurrency("EUR")); + entityManager.persist(order1); + + Order order2 = new Order(); + order2.setCurrency(getCurrency("PLN")); + entityManager.persist(order2); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = getCurrency("PLN"); + Order order = entityManager.createQuery("select o from Order o where o.currency = :currency", Order.class) + .setParameter("currency", currency) + .getSingleResult(); + + assertEquals(Long.valueOf(2), order.getId()); + }); + } + + @Test + public void testReturnNullCurrency() { + Long _id = doInJPA(entityManager -> { + Order order = new Order(); + entityManager.persist(order); + + return order.getId(); + }); + + doInJPA(entityManager -> { + Order order = entityManager.createQuery("select o from Order o where o.id = :id", Order.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(order.getCurrency()); + }); + + doInJPA(entityManager -> { + CurrencyUnit currency = entityManager.createQuery("select o.currency from Order o where o.id = :id", CurrencyUnit.class) + .setParameter("id", _id) + .getSingleResult(); + + assertNull(currency); + }); + } + + @Entity(name = "Order") + @Table(name = "orders") + public static class Order { + @Id + @GeneratedValue + private Long id; + + @Type(CurrencyUnitType.class) + @Column(name = "currency", columnDefinition = "char(3)") + private CurrencyUnit currency; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public CurrencyUnit getCurrency() { + return currency; + } + + public void setCurrency(CurrencyUnit currency) { + this.currency = currency; + } + } +} diff --git a/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java b/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java index 558f8b0d8..6e8a99657 100644 --- a/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java +++ b/hibernate-types-60/src/test/java/com/vladmihalcea/hibernate/type/money/PostgreSQLMonetaryAmountTypeTest.java @@ -55,7 +55,7 @@ public void testSearchByMoney() { doInJPA(entityManager -> { Money money = Money.of(new BigDecimal("10.23"), "USD"); - Salary salary = entityManager.createQuery("select s from Salary s where salary = :salary", Salary.class) + Salary salary = entityManager.createQuery("select s from Salary s where s.salary = :salary", Salary.class) .setParameter("salary", money) .getSingleResult(); @@ -73,16 +73,16 @@ public void testReturnNullMoney() { doInJPA(entityManager -> { Salary salary = entityManager.createQuery("select s from Salary s where s.id = :id", Salary.class) - .setParameter("id", _id) - .getSingleResult(); + .setParameter("id", _id) + .getSingleResult(); assertNull(salary.getSalary()); }); doInJPA(entityManager -> { MonetaryAmount money = entityManager.createQuery("select s.salary from Salary s where s.id = :id", MonetaryAmount.class) - .setParameter("id", _id) - .getSingleResult(); + .setParameter("id", _id) + .getSingleResult(); assertNull(money); });