├── .gitignore ├── .project ├── .settings ├── org.eclipse.core.resources.prefs └── org.eclipse.m2e.core.prefs ├── 2ndLevelCache ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── Test2ndLevelCache.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── AccessHibernateApi ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestAccessHibernateApi.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── AssociationBidirectionalManyToMany ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestBidirectionalManyToMany.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── AssociationBidirectionalManyToOne ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ └── Review.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestBidirectionalOneToMany.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── AssociationBidirectionalOneToOne ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ └── Manuscript.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestBidirectionalOneToOne.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── AssociationUnidirectionalManyToMany ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestUnidirectionalManyToMany.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── AssociationUnidirectionalManyToOne ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ └── Review.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestUnidirectionalOneToMany.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── AssociationUnidirectionalOneToMany ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ └── Review.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestUnidirectionalOneToMany.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── AssociationUnidirectionalOneToOne ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ └── Manuscript.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestUnidirectionalOneToOne.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── AssociationsWithAttributes ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ ├── BookPublisher.java │ │ │ ├── BookPublisherId.java │ │ │ ├── Format.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestAssociation.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── AttributeConverterForDateAndTime ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── AuthorStatus.java │ │ │ └── LocalDateConverter.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestAttributeConverter.java │ └── resources │ └── log4j.properties ├── CascadePersist ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestCascadePersist.java │ └── resources │ └── log4j.properties ├── CheckSQLStatementCount ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestStatistics.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── CommentSQLStatements ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestLogging.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── CriteriaConstructor ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── AuthorValue.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestCriteriaConstructor.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── CriteriaCustomFunction ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestCriteriaConstructor.java │ └── resources │ ├── create-database.sql │ ├── data.sql │ └── log4j.properties ├── CriteriaDelete ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestCriteriaDelete.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── CriteriaQuery ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestCriteriaQuery.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── CriteriaQueryPagination ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestQueryPagination.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── CriteriaStandardFunction ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestCriteriaFunction.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── CriteriaTuples ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestCriteriaTuples.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── CriteriaUpdate ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestCriteriaUpdate.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── CustomEnumerationsMapping ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── AuthorStatus.java │ │ │ └── AuthorStatusConverter.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestEnum.java │ └── resources │ └── log4j.properties ├── CustomSequence ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestCustomSequence.java │ └── resources │ └── log4j.properties ├── DatabaseViews ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ ├── BookView.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestViewEntity.java │ └── resources │ ├── create-database.sql │ ├── data.sql │ ├── drop-database.sql │ └── log4j.properties ├── DateAndTime ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestDateAndTime.java │ └── resources │ └── log4j.properties ├── DefineTableAndSchemaName ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ ├── create-database.sql │ │ ├── drop-database.sql │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestTableAndSchemaName.java │ └── resources │ ├── create-database.sql │ └── log4j.properties ├── DerivedPrimaryKey ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ ├── Review.java │ │ │ └── ReviewId.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestDerivedPrimaryKey.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── EntityGraph ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestEntityGraph.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── Formula ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestFormula.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── HibernateBootstrapping ├── .gitignore ├── pom.xml └── src │ ├── main │ └── java │ │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── Author.java │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestHibernateBootstrapping.java │ └── resources │ ├── hibernate.cfg.xml │ └── log4j.properties ├── HibernateJoinUnassociatedEntities ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ └── Review.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJoinUnassociatedEntities.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── HibernateMultipleId ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestMultipleId.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── HibernateNaturalId ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestNaturalId.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── InheritanceJoined ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── BlogPost.java │ │ │ ├── Book.java │ │ │ └── Publication.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestInheritance.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── InheritanceMappedSuperclass ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── BlogPost.java │ │ │ ├── Book.java │ │ │ └── Publication.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestInheritance.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── InheritanceSingleTable ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── BlogPost.java │ │ │ ├── Book.java │ │ │ └── Publication.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestInheritance.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── InheritanceTablePerClass ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── BlogPost.java │ │ │ ├── Book.java │ │ │ └── Publication.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestInheritance.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── JPABootstrapping ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJPABootstrapping.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── JPAMetamodel ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestMetamodel.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── JPQLAdHocQuery ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJpqlQuery.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── JPQLConstructorExpression ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ ├── BookValue.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJpqlQuery.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── JPQLCustomFunction ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJPQLCustomFunction.java │ └── resources │ ├── create-database.sql │ ├── data.sql │ └── log4j.properties ├── JPQLDelete ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJPQLDelete.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── JPQLNamedQuery ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJpqlQuery.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── JPQLScalarValues ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ ├── BookValue.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJpqlQuery.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── JPQLUpdate ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJPQLUpdate.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── JoinFetch ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJoinFetch.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── JpqlStandardFunction ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestJpqlFunction.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── LICENSE ├── LogSQLStatements ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestLogging.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── MapBasicAttributes ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestAttributeMapping.java │ └── resources │ └── log4j.properties ├── MapEnumerations ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ └── AuthorStatus.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestEnum.java │ └── resources │ └── log4j.properties ├── MapGeneratedColumns ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestGeneratedColumn.java │ └── resources │ ├── create.sql │ └── log4j.properties ├── MapNativeQueryToEntity ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestMapNativeQuery.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── MapNativeQueryToPojo ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ ├── BookValue.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestMapNativeQuery.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── MapOptionalAssociations ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestMapOptionalAssociation.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── MapUtilDate ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestAttributeMapping.java │ └── resources │ └── log4j.properties ├── NamedNativeQuery ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestNamedNativeQuery.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── NativeQuery ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestNativeQuery.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── OrderRelationships ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestOrderRelationships.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── PrePersistLifecycleEvent ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestPrePersist.java │ └── resources │ └── log4j.properties ├── PrimaryKey ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestPrimaryKey.java │ └── resources │ └── log4j.properties ├── PrimaryKeyIdentityStrategy ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestIdentityStrategy.java │ └── resources │ └── log4j.properties ├── PrimaryKeyTableStrategy ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestTableStrategy.java │ └── resources │ └── log4j.properties ├── PrimaryKeyUUID ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestUUIDPrimaryKey.java │ └── resources │ └── log4j.properties ├── QueryCache ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestQueryCache.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── QueryPagination ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestQueryPagination.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── QueryTimeout ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── Book.java │ │ │ └── Publisher.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestQueryTimeout.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── README.md ├── ResultsAsStreams ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Book.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestStream.java │ └── resources │ └── log4j.properties ├── SpringBootBootstrapping ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ ├── DemoApplication.java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── application.properties │ └── test │ └── java │ └── org │ └── thoughts │ └── on │ └── java │ └── SpringBootstrappingTest.java ├── StoredProcedureQuery ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ ├── TestNamedStoredProcedureQuery.java │ │ └── TestStoredProcedureQuery.java │ └── resources │ ├── create-database.sql │ └── log4j.properties ├── TransientAttributes ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ └── Author.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestTransient.java │ └── resources │ ├── data.sql │ └── log4j.properties ├── Treat ├── .gitignore ├── pom.xml └── src │ ├── main │ ├── java │ │ └── org │ │ │ └── thoughts │ │ │ └── on │ │ │ └── java │ │ │ └── model │ │ │ ├── Author.java │ │ │ ├── BlogPost.java │ │ │ ├── Book.java │ │ │ └── Publication.java │ └── resources │ │ └── META-INF │ │ └── persistence.xml │ └── test │ ├── java │ └── org │ │ └── thoughts │ │ └── on │ │ └── java │ │ └── model │ │ └── TestTreat.java │ └── resources │ ├── data.sql │ └── log4j.properties └── pom.xml /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | 3 | # Mobile Tools for Java (J2ME) 4 | .mtj.tmp/ 5 | 6 | # Package Files # 7 | *.jar 8 | *.war 9 | *.ear 10 | 11 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 12 | hs_err_pid* 13 | 14 | */target/** 15 | */.settings/ 16 | */.project 17 | */.classpath 18 | /.settings/ 19 | /.project 20 | -------------------------------------------------------------------------------- /.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | HibernateTips 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.m2e.core.maven2Builder 10 | 11 | 12 | 13 | 14 | 15 | org.eclipse.m2e.core.maven2Nature 16 | 17 | 18 | -------------------------------------------------------------------------------- /.settings/org.eclipse.core.resources.prefs: -------------------------------------------------------------------------------- 1 | eclipse.preferences.version=1 2 | encoding/=UTF-8 3 | -------------------------------------------------------------------------------- /.settings/org.eclipse.m2e.core.prefs: -------------------------------------------------------------------------------- 1 | activeProfiles= 2 | eclipse.preferences.version=1 3 | resolveWorkspaceProjects=true 4 | version=1 5 | -------------------------------------------------------------------------------- /2ndLevelCache/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /2ndLevelCache/src/test/java/org/thoughts/on/java/model/Test2ndLevelCache.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Before; 10 | import org.junit.Test; 11 | 12 | public class Test2ndLevelCache { 13 | 14 | Logger log = Logger.getLogger(this.getClass().getName()); 15 | 16 | private EntityManagerFactory emf; 17 | 18 | @Before 19 | public void init() { 20 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 21 | } 22 | 23 | @After 24 | public void close() { 25 | emf.close(); 26 | } 27 | 28 | @Test 29 | public void selectAuthor() { 30 | log.info("... selectAuthor ..."); 31 | 32 | log.info("Session 1"); 33 | EntityManager em = emf.createEntityManager(); 34 | em.getTransaction().begin(); 35 | 36 | Author a = em.find(Author.class, 1L); 37 | log.info(a); 38 | 39 | em.getTransaction().commit(); 40 | em.close(); 41 | 42 | log.info("Session 2"); 43 | em = emf.createEntityManager(); 44 | em.getTransaction().begin(); 45 | 46 | a = em.find(Author.class, 1L); 47 | log.info(a); 48 | 49 | em.getTransaction().commit(); 50 | em.close(); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /2ndLevelCache/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, version) VALUES (1, 'Joshua', 'Bloch', 0); 2 | INSERT INTO author (id, firstname, lastname, version) VALUES (2, 'Gavin', 'King', 0); 3 | INSERT INTO author (id, firstname, lastname, version) VALUES (3, 'Christian', 'Bauer', 0); 4 | INSERT INTO author (id, firstname, lastname, version) VALUES (4, 'Gary', 'Gregory', 0); 5 | INSERT INTO author (id, firstname, lastname, version) VALUES (5, 'Raoul-Gabriel', 'Urma', 0); 6 | INSERT INTO author (id, firstname, lastname, version) VALUES (6, 'Mario', 'Fusco', 0); 7 | INSERT INTO author (id, firstname, lastname, version) VALUES (7, 'Alan', 'Mycroft', 0); 8 | INSERT INTO author (id, firstname, lastname, version) VALUES (8, 'Andrew Lee', 'Rubinger', 0); 9 | INSERT INTO author (id, firstname, lastname, version) VALUES (9, 'Aslak', 'Knutsen', 0); 10 | INSERT INTO author (id, firstname, lastname, version) VALUES (10, 'Bill', 'Burke', 0); 11 | INSERT INTO author (id, firstname, lastname, version) VALUES (11, 'Scott', 'Oaks', 0); -------------------------------------------------------------------------------- /2ndLevelCache/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /AccessHibernateApi/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /AccessHibernateApi/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /AccessHibernateApi/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, version) VALUES (1, 'Joshua', 'Bloch', 0); 2 | INSERT INTO author (id, firstname, lastname, version) VALUES (2, 'Gavin', 'King', 0); 3 | INSERT INTO author (id, firstname, lastname, version) VALUES (3, 'Christian', 'Bauer', 0); 4 | INSERT INTO author (id, firstname, lastname, version) VALUES (4, 'Gary', 'Gregory', 0); 5 | INSERT INTO author (id, firstname, lastname, version) VALUES (5, 'Raoul-Gabriel', 'Urma', 0); 6 | INSERT INTO author (id, firstname, lastname, version) VALUES (6, 'Mario', 'Fusco', 0); 7 | INSERT INTO author (id, firstname, lastname, version) VALUES (7, 'Alan', 'Mycroft', 0); 8 | INSERT INTO author (id, firstname, lastname, version) VALUES (8, 'Andrew Lee', 'Rubinger', 0); 9 | INSERT INTO author (id, firstname, lastname, version) VALUES (9, 'Aslak', 'Knutsen', 0); 10 | INSERT INTO author (id, firstname, lastname, version) VALUES (10, 'Bill', 'Burke', 0); 11 | INSERT INTO author (id, firstname, lastname, version) VALUES (11, 'Scott', 'Oaks', 0); -------------------------------------------------------------------------------- /AccessHibernateApi/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /AssociationBidirectionalManyToMany/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /AssociationBidirectionalManyToMany/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /AssociationBidirectionalManyToMany/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, title, version) VALUES (1, 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /AssociationBidirectionalManyToMany/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /AssociationBidirectionalManyToOne/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /AssociationBidirectionalManyToOne/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /AssociationBidirectionalManyToOne/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, title, version) VALUES (1, 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /AssociationBidirectionalManyToOne/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /AssociationBidirectionalOneToOne/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /AssociationBidirectionalOneToOne/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /AssociationBidirectionalOneToOne/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, title, version) VALUES (1, 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /AssociationBidirectionalOneToOne/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /AssociationUnidirectionalManyToMany/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /AssociationUnidirectionalManyToMany/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /AssociationUnidirectionalManyToMany/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, title, version) VALUES (1, 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /AssociationUnidirectionalManyToMany/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /AssociationUnidirectionalManyToOne/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /AssociationUnidirectionalManyToOne/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /AssociationUnidirectionalManyToOne/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, title, version) VALUES (1, 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /AssociationUnidirectionalManyToOne/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /AssociationUnidirectionalOneToMany/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /AssociationUnidirectionalOneToMany/src/main/java/org/thoughts/on/java/model/Review.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.Column; 4 | import javax.persistence.Entity; 5 | import javax.persistence.GeneratedValue; 6 | import javax.persistence.GenerationType; 7 | import javax.persistence.Id; 8 | 9 | @Entity 10 | public class Review { 11 | 12 | @Id 13 | @GeneratedValue(strategy = GenerationType.AUTO) 14 | @Column(name = "id", updatable = false, nullable = false) 15 | private Long id; 16 | 17 | private String comment; 18 | 19 | public Long getId() { 20 | return id; 21 | } 22 | 23 | public String getComment() { 24 | return comment; 25 | } 26 | 27 | public void setComment(String comment) { 28 | this.comment = comment; 29 | } 30 | 31 | @Override 32 | public int hashCode() { 33 | return 31; 34 | } 35 | 36 | @Override 37 | public boolean equals(Object obj) { 38 | if (this == obj) 39 | return true; 40 | if (obj == null) 41 | return false; 42 | if (getClass() != obj.getClass()) 43 | return false; 44 | Review other = (Review) obj; 45 | if (id == null) { 46 | if (other.id != null) 47 | return false; 48 | } else if (!id.equals(other.id)) 49 | return false; 50 | return true; 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /AssociationUnidirectionalOneToMany/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, title, version) VALUES (1, 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /AssociationUnidirectionalOneToMany/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /AssociationUnidirectionalOneToOne/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /AssociationUnidirectionalOneToOne/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /AssociationUnidirectionalOneToOne/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, title, version) VALUES (1, 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /AssociationUnidirectionalOneToOne/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /AssociationsWithAttributes/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /AssociationsWithAttributes/src/main/java/org/thoughts/on/java/model/Format.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | public enum Format { 4 | 5 | HARDCOVER, PAPERBACK, EBOOK; 6 | } 7 | -------------------------------------------------------------------------------- /AssociationsWithAttributes/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /AssociationsWithAttributes/src/test/java/org/thoughts/on/java/model/TestAssociation.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Before; 10 | import org.junit.Test; 11 | 12 | public class TestAssociation { 13 | 14 | Logger log = Logger.getLogger(this.getClass().getName()); 15 | 16 | private EntityManagerFactory emf; 17 | 18 | @Before 19 | public void init() { 20 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 21 | } 22 | 23 | @After 24 | public void close() { 25 | emf.close(); 26 | } 27 | 28 | @Test 29 | public void associationWithAttributes() { 30 | log.info("... associationWithAttributes ..."); 31 | 32 | EntityManager em = emf.createEntityManager(); 33 | em.getTransaction().begin(); 34 | 35 | Book b = em.find(Book.class, 1L); 36 | Publisher p = em.find(Publisher.class, 1L); 37 | 38 | BookPublisher bp = new BookPublisher(); 39 | bp.setId(new BookPublisherId()); 40 | bp.setBook(b); 41 | bp.setPublisher(p); 42 | bp.setFormat(Format.PAPERBACK); 43 | 44 | em.persist(bp); 45 | 46 | em.getTransaction().commit(); 47 | em.close(); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /AssociationsWithAttributes/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, title, version) VALUES (1, 'Hibernate Tips', 0); 2 | 3 | INSERT INTO publisher (id, name, version) VALUES (1, 'Thoughts on Java', 0); -------------------------------------------------------------------------------- /AssociationsWithAttributes/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /AttributeConverterForDateAndTime/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /AttributeConverterForDateAndTime/src/main/java/org/thoughts/on/java/model/AuthorStatus.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | public enum AuthorStatus { 4 | 5 | PUBLISHED, SELF_PUBLISHED, NOT_PUBLISHED; 6 | } 7 | -------------------------------------------------------------------------------- /AttributeConverterForDateAndTime/src/main/java/org/thoughts/on/java/model/LocalDateConverter.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import java.sql.Date; 4 | import java.time.LocalDate; 5 | 6 | import javax.persistence.AttributeConverter; 7 | import javax.persistence.Converter; 8 | 9 | import org.apache.log4j.Logger; 10 | 11 | @Converter(autoApply = true) 12 | public class LocalDateConverter implements AttributeConverter { 13 | 14 | Logger log = Logger.getLogger(LocalDateConverter.class.getSimpleName()); 15 | 16 | @Override 17 | public Date convertToDatabaseColumn(LocalDate attribute) { 18 | log.info("Convert to java.sql.Date"); 19 | return Date.valueOf(attribute); 20 | } 21 | 22 | @Override 23 | public LocalDate convertToEntityAttribute(Date dbData) { 24 | log.info("Convert to java.time.LocalDate"); 25 | return dbData.toLocalDate(); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /AttributeConverterForDateAndTime/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 20 | 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /AttributeConverterForDateAndTime/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /CascadePersist/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CascadePersist/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /CascadePersist/src/test/java/org/thoughts/on/java/model/TestCascadePersist.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Before; 10 | import org.junit.Test; 11 | 12 | public class TestCascadePersist { 13 | 14 | Logger log = Logger.getLogger(this.getClass().getName()); 15 | 16 | private EntityManagerFactory emf; 17 | 18 | @Before 19 | public void init() { 20 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 21 | } 22 | 23 | @After 24 | public void close() { 25 | emf.close(); 26 | } 27 | 28 | @Test 29 | public void testCascade() { 30 | log.info("... testCascade ..."); 31 | 32 | EntityManager em = emf.createEntityManager(); 33 | em.getTransaction().begin(); 34 | 35 | Author a = new Author(); 36 | a.setFirstName("John"); 37 | a.setLastName("Doe"); 38 | 39 | Book b1 = new Book(); 40 | b1.setTitle("John's first book"); 41 | a.getBooks().add(b1); 42 | 43 | Book b2 = new Book(); 44 | b2.setTitle("John's second book"); 45 | a.getBooks().add(b2); 46 | 47 | em.persist(a); 48 | 49 | em.getTransaction().commit(); 50 | em.close(); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /CascadePersist/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /CheckSQLStatementCount/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CheckSQLStatementCount/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /CheckSQLStatementCount/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | #log4j.logger.org.hibernate.stat=debug -------------------------------------------------------------------------------- /CommentSQLStatements/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | .settings/ 3 | .project 4 | .classpath -------------------------------------------------------------------------------- /CommentSQLStatements/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /CommentSQLStatements/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, version) VALUES (1, 'Joshua', 'Bloch', 0); 2 | INSERT INTO author (id, firstname, lastname, version) VALUES (2, 'Gavin', 'King', 0); 3 | INSERT INTO author (id, firstname, lastname, version) VALUES (3, 'Christian', 'Bauer', 0); 4 | INSERT INTO author (id, firstname, lastname, version) VALUES (4, 'Gary', 'Gregory', 0); 5 | INSERT INTO author (id, firstname, lastname, version) VALUES (5, 'Raoul-Gabriel', 'Urma', 0); 6 | INSERT INTO author (id, firstname, lastname, version) VALUES (6, 'Mario', 'Fusco', 0); 7 | INSERT INTO author (id, firstname, lastname, version) VALUES (7, 'Alan', 'Mycroft', 0); 8 | INSERT INTO author (id, firstname, lastname, version) VALUES (8, 'Andrew Lee', 'Rubinger', 0); 9 | INSERT INTO author (id, firstname, lastname, version) VALUES (9, 'Aslak', 'Knutsen', 0); 10 | INSERT INTO author (id, firstname, lastname, version) VALUES (10, 'Bill', 'Burke', 0); 11 | INSERT INTO author (id, firstname, lastname, version) VALUES (11, 'Scott', 'Oaks', 0); -------------------------------------------------------------------------------- /CommentSQLStatements/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /CriteriaConstructor/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CriteriaConstructor/src/main/java/org/thoughts/on/java/model/AuthorValue.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | public class AuthorValue { 4 | 5 | private String firstName; 6 | private String lastName; 7 | 8 | public AuthorValue(String firstName, String lastName) { 9 | this.firstName = firstName; 10 | this.lastName = lastName; 11 | } 12 | 13 | public String getFirstName() { 14 | return firstName; 15 | } 16 | 17 | public void setFirstName(String firstName) { 18 | this.firstName = firstName; 19 | } 20 | 21 | public String getLastName() { 22 | return lastName; 23 | } 24 | 25 | public void setLastName(String lastName) { 26 | this.lastName = lastName; 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /CriteriaConstructor/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /CriteriaConstructor/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /CriteriaCustomFunction/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CriteriaCustomFunction/src/test/resources/create-database.sql: -------------------------------------------------------------------------------- 1 | CREATE OR REPLACE FUNCTION calculate(IN x double precision, IN y double precision, OUT sum double precision) RETURNS double precision AS $BODY$ BEGIN sum = x + y; END; $BODY$ LANGUAGE plpgsql VOLATILE COST 100; 2 | ALTER FUNCTION calculate(double precision, double precision) OWNER TO postgres; 3 | 4 | CREATE TABLE book (id bigint NOT NULL, publishingdate date, title character varying(255), price double precision, version integer, CONSTRAINT book_pkey PRIMARY KEY (id)) 5 | 6 | CREATE SEQUENCE hibernate_sequence INCREMENT 1 MINVALUE 1 MAXVALUE 9223372036854775807 START 1 CACHE 1; -------------------------------------------------------------------------------- /CriteriaCustomFunction/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (1, '2008-05-08', 'Effective Java', 33.0, 0); 2 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (2, '2015-10-01', 'Java Persistence with Hibernate', 42.0, 0); 3 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (3, '2014-08-28', 'Java 8 in Action', 49.0, 0); 4 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (4, '2014-03-12', 'Continuous Enterprise Development in Java', 26.0, 0); 5 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (5, '2010-09-08', 'Enterprise JavaBeans 3.1', 45.0, 0); 6 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (6, '2014-04-29', 'Java Performance The Definitive Guide', 22.0, 0); -------------------------------------------------------------------------------- /CriteriaCustomFunction/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /CriteriaDelete/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CriteriaDelete/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /CriteriaDelete/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /CriteriaQuery/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CriteriaQuery/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /CriteriaQuery/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /CriteriaQueryPagination/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CriteriaQueryPagination/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /CriteriaQueryPagination/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2017-04-04', 'Hibernate Tips 1', 0); 2 | INSERT INTO book (id, publishingdate, title, version) VALUES (2, '2017-04-04', 'Hibernate Tips 2', 0); 3 | INSERT INTO book (id, publishingdate, title, version) VALUES (3, '2017-04-04', 'Hibernate Tips 3', 0); 4 | INSERT INTO book (id, publishingdate, title, version) VALUES (4, '2017-04-04', 'Hibernate Tips 4', 0); 5 | INSERT INTO book (id, publishingdate, title, version) VALUES (5, '2017-04-04', 'Hibernate Tips 5', 0); 6 | INSERT INTO book (id, publishingdate, title, version) VALUES (6, '2017-04-04', 'Hibernate Tips 6', 0); 7 | INSERT INTO book (id, publishingdate, title, version) VALUES (7, '2017-04-04', 'Hibernate Tips 7', 0); 8 | INSERT INTO book (id, publishingdate, title, version) VALUES (8, '2017-04-04', 'Hibernate Tips 8', 0); 9 | INSERT INTO book (id, publishingdate, title, version) VALUES (9, '2017-04-04', 'Hibernate Tips 9', 0); 10 | INSERT INTO book (id, publishingdate, title, version) VALUES (10, '2017-04-04', 'Hibernate Tips 10', 0); 11 | INSERT INTO book (id, publishingdate, title, version) VALUES (11, '2017-04-04', 'Hibernate Tips 11', 0); 12 | INSERT INTO book (id, publishingdate, title, version) VALUES (12, '2017-04-04', 'Hibernate Tips 12', 0); 13 | INSERT INTO book (id, publishingdate, title, version) VALUES (13, '2017-04-04', 'Hibernate Tips 13', 0); -------------------------------------------------------------------------------- /CriteriaQueryPagination/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /CriteriaStandardFunction/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CriteriaStandardFunction/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /CriteriaTuples/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CriteriaTuples/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /CriteriaTuples/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /CriteriaUpdate/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CriteriaUpdate/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /CriteriaUpdate/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /CustomEnumerationsMapping/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CustomEnumerationsMapping/src/main/java/org/thoughts/on/java/model/AuthorStatus.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | public enum AuthorStatus { 4 | 5 | PUBLISHED, SELF_PUBLISHED, NOT_PUBLISHED; 6 | } 7 | -------------------------------------------------------------------------------- /CustomEnumerationsMapping/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 20 | 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /CustomEnumerationsMapping/src/test/java/org/thoughts/on/java/model/TestEnum.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Before; 10 | import org.junit.Test; 11 | 12 | public class TestEnum { 13 | 14 | Logger log = Logger.getLogger(this.getClass().getName()); 15 | 16 | private EntityManagerFactory emf; 17 | 18 | @Before 19 | public void init() { 20 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 21 | } 22 | 23 | @After 24 | public void close() { 25 | emf.close(); 26 | } 27 | 28 | @Test 29 | public void persistAndLoad() { 30 | log.info("... persistAndLoad ..."); 31 | 32 | EntityManager em = emf.createEntityManager(); 33 | em.getTransaction().begin(); 34 | 35 | Author a = new Author(); 36 | a.setFirstName("John"); 37 | a.setLastName("Doe"); 38 | a.setStatus(AuthorStatus.PUBLISHED); 39 | 40 | em.persist(a); 41 | 42 | em.getTransaction().commit(); 43 | em.close(); 44 | 45 | em = emf.createEntityManager(); 46 | em.getTransaction().begin(); 47 | 48 | a = em.find(Author.class, a.getId()); 49 | log.info(a); 50 | 51 | em.getTransaction().commit(); 52 | em.close(); 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /CustomEnumerationsMapping/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /CustomSequence/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /CustomSequence/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /CustomSequence/src/test/java/org/thoughts/on/java/model/TestCustomSequence.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Before; 10 | import org.junit.Test; 11 | 12 | public class TestCustomSequence { 13 | 14 | Logger log = Logger.getLogger(this.getClass().getName()); 15 | 16 | private EntityManagerFactory emf; 17 | 18 | @Before 19 | public void init() { 20 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 21 | } 22 | 23 | @After 24 | public void close() { 25 | emf.close(); 26 | } 27 | 28 | @Test 29 | public void useCustomSequence() { 30 | log.info("... useCustomSequence ..."); 31 | 32 | EntityManager em = emf.createEntityManager(); 33 | em.getTransaction().begin(); 34 | 35 | Author a = new Author(); 36 | a.setFirstName("firstName"); 37 | a.setLastName("lastName"); 38 | 39 | em.persist(a); 40 | 41 | em.getTransaction().commit(); 42 | em.close(); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /CustomSequence/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /DatabaseViews/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /DatabaseViews/src/test/resources/create-database.sql: -------------------------------------------------------------------------------- 1 | CREATE TABLE author(id bigint NOT NULL, firstname character varying(255), lastname character varying(255), version integer NOT NULL, CONSTRAINT author_pkey PRIMARY KEY (id)); 2 | 3 | CREATE TABLE book(id bigint NOT NULL, publishingdate date, title character varying(255), version integer, CONSTRAINT book_pkey PRIMARY KEY (id)); 4 | 5 | CREATE TABLE bookauthor(bookid bigint NOT NULL, authorid bigint NOT NULL, CONSTRAINT bookauthor_pkey PRIMARY KEY (bookid, authorid), CONSTRAINT fk1vpkcbic0iljxqxu629o36mpc FOREIGN KEY (bookid) REFERENCES book (id)); 6 | 7 | CREATE OR REPLACE VIEW bookview AS SELECT b.id, b.publishingdate, b.title, b.version, string_agg(a.name, ', '::text) AS authors FROM book b JOIN ( SELECT (a_1.firstname::text || ' '::text) || a_1.lastname::text AS name, b_1.id AS bookid FROM book b_1 JOIN bookauthor ba ON b_1.id = ba.bookid JOIN author a_1 ON a_1.id = ba.authorid) a ON a.bookid = b.id GROUP BY b.id; -------------------------------------------------------------------------------- /DatabaseViews/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, version) VALUES (1, 'Thorben', 'Janssen', 0); 2 | 3 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2017-04-04', 'Hibernate Tips', 0); 4 | 5 | INSERT INTO bookauthor (bookid, authorid) VALUES (1, 1); 6 | -------------------------------------------------------------------------------- /DatabaseViews/src/test/resources/drop-database.sql: -------------------------------------------------------------------------------- 1 | drop table if exists BookAuthor cascade 2 | drop table if exists Author cascade 3 | drop table if exists Book cascade 4 | drop table if exists Publisher cascade -------------------------------------------------------------------------------- /DatabaseViews/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /DateAndTime/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /DateAndTime/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /DateAndTime/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /DefineTableAndSchemaName/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /DefineTableAndSchemaName/src/main/resources/META-INF/create-database.sql: -------------------------------------------------------------------------------- 1 | CREATE SCHEMA IF NOT EXISTS bookstore; 2 | 3 | CREATE TABLE bookstore.author (id bigint NOT NULL,firstname character varying(255),lastname character varying(255),version integer NOT NULL,CONSTRAINT author_pkey PRIMARY KEY (id)); 4 | 5 | CREATE SEQUENCE hibernate_sequence INCREMENT 1 MINVALUE 1 MAXVALUE 9223372036854775807 START 1; -------------------------------------------------------------------------------- /DefineTableAndSchemaName/src/main/resources/META-INF/drop-database.sql: -------------------------------------------------------------------------------- 1 | DROP SCHEMA IF EXISTS bookstore CASCADE; 2 | DROP SEQUENCE hibernate_sequence -------------------------------------------------------------------------------- /DefineTableAndSchemaName/src/test/resources/create-database.sql: -------------------------------------------------------------------------------- 1 | CREATE SCHEMA IF NOT EXISTS bookstore; 2 | 3 | CREATE TABLE bookstore.author 4 | ( 5 | id bigint NOT NULL, 6 | firstname character varying(255), 7 | lastname character varying(255), 8 | version integer NOT NULL, 9 | CONSTRAINT author_pkey PRIMARY KEY (id) 10 | ) 11 | 12 | CREATE SEQUENCE bookstore.hibernate_sequence 13 | INCREMENT 1 14 | MINVALUE 1 15 | MAXVALUE 9223372036854775807 16 | START 1 17 | CACHE 1; -------------------------------------------------------------------------------- /DefineTableAndSchemaName/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /DerivedPrimaryKey/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /DerivedPrimaryKey/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2017-04-04', 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /DerivedPrimaryKey/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /EntityGraph/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /EntityGraph/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /EntityGraph/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /Formula/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /Formula/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /Formula/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, dateOfBirth, version) VALUES (1, 'John', 'Doe', '12-4-1973', 0); 2 | -------------------------------------------------------------------------------- /Formula/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /HibernateBootstrapping/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /HibernateBootstrapping/src/test/java/org/thoughts/on/java/model/TestHibernateBootstrapping.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import org.apache.log4j.Logger; 4 | import org.hibernate.Session; 5 | import org.hibernate.SessionFactory; 6 | import org.hibernate.boot.MetadataSources; 7 | import org.hibernate.boot.registry.StandardServiceRegistryBuilder; 8 | import org.hibernate.service.ServiceRegistry; 9 | import org.junit.Test; 10 | 11 | public class TestHibernateBootstrapping { 12 | 13 | Logger log = Logger.getLogger(this.getClass().getName()); 14 | 15 | @Test 16 | public void bootstrapping() { 17 | log.info("... bootstrapping ..."); 18 | 19 | ServiceRegistry standardRegistry = new StandardServiceRegistryBuilder().configure().build(); 20 | 21 | SessionFactory sessionFactory = new MetadataSources(standardRegistry) 22 | .addAnnotatedClass(Author.class).buildMetadata() 23 | .buildSessionFactory(); 24 | Session session = sessionFactory.openSession(); 25 | session.beginTransaction(); 26 | 27 | Author a = new Author(); 28 | a.setFirstName("Thorben"); 29 | a.setLastName("Janssen"); 30 | session.persist(a); 31 | 32 | session.getTransaction().commit(); 33 | session.close(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /HibernateBootstrapping/src/test/resources/hibernate.cfg.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | org.postgresql.Driver 5 | jdbc:postgresql://localhost:5432/recipes 6 | postgres 7 | postgres 8 | 1 9 | 10 | org.hibernate.dialect.PostgreSQLDialect 11 | 12 | create 13 | 14 | -------------------------------------------------------------------------------- /HibernateBootstrapping/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /HibernateJoinUnassociatedEntities/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /HibernateJoinUnassociatedEntities/src/test/java/org/thoughts/on/java/model/TestJoinUnassociatedEntities.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | import javax.persistence.Query; 7 | 8 | import org.apache.log4j.Logger; 9 | import org.junit.After; 10 | import org.junit.Before; 11 | import org.junit.Test; 12 | 13 | public class TestJoinUnassociatedEntities { 14 | 15 | Logger log = Logger.getLogger(this.getClass().getName()); 16 | 17 | private EntityManagerFactory emf; 18 | 19 | @Before 20 | public void init() { 21 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 22 | } 23 | 24 | @After 25 | public void close() { 26 | emf.close(); 27 | } 28 | 29 | @Test 30 | public void joinUnassociated() { 31 | log.info("... joinUnassociated ..."); 32 | 33 | EntityManager em = emf.createEntityManager(); 34 | em.getTransaction().begin(); 35 | 36 | Query q = em.createQuery("SELECT b.title, count(r.id) FROM Book b INNER JOIN Review r ON r.fkBook = b.id GROUP BY b.title"); 37 | Object[] r = (Object[]) q.getSingleResult(); 38 | log.info(r[0] + " received " + r[1] + " reviews."); 39 | 40 | em.getTransaction().commit(); 41 | em.close(); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /HibernateJoinUnassociatedEntities/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2017-04-04', 'Hibernate Tips', 0); 2 | 3 | INSERT INTO review (id, comment, fkBook) VALUES (1, 'This is a review', 1); 4 | INSERT INTO review (id, comment, fkBook) VALUES (2, 'This is another review', 1); -------------------------------------------------------------------------------- /HibernateJoinUnassociatedEntities/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /HibernateMultipleId/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /HibernateMultipleId/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2017-04-04', 'Hibernate Tips', 0); 2 | INSERT INTO book (id, publishingdate, title, version) VALUES (2, '2018-04-04', 'Another Book', 0); 3 | INSERT INTO book (id, publishingdate, title, version) VALUES (3, '2019-04-04', 'My 3rd Book', 0); 4 | -------------------------------------------------------------------------------- /HibernateMultipleId/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /HibernateNaturalId/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /HibernateNaturalId/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, isbn, version) VALUES (1, '2017-04-04', 'Hibernate Tips', '123-4567890123', 0); 2 | 3 | INSERT INTO review (id, comment, fkBook) VALUES (1, 'This is a review', 1); 4 | INSERT INTO review (id, comment, fkBook) VALUES (2, 'This is another review', 1); -------------------------------------------------------------------------------- /HibernateNaturalId/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /InheritanceJoined/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /InheritanceJoined/src/main/java/org/thoughts/on/java/model/BlogPost.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.Entity; 4 | 5 | @Entity 6 | public class BlogPost extends Publication { 7 | 8 | private String url; 9 | 10 | public String getUrl() { 11 | return url; 12 | } 13 | 14 | public void setUrl(String url) { 15 | this.url = url; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "BlogPost [url=" + url + "]"; 21 | } 22 | 23 | @Override 24 | public int hashCode() { 25 | return 31; 26 | } 27 | 28 | @Override 29 | public boolean equals(Object obj) { 30 | if (this == obj) 31 | return true; 32 | if (obj == null) 33 | return false; 34 | if (getClass() != obj.getClass()) 35 | return false; 36 | BlogPost other = (BlogPost) obj; 37 | if (getId() != null) { 38 | if (!getId().equals(other.getId())) { 39 | return false; 40 | } 41 | } 42 | return true; 43 | } 44 | 45 | 46 | } 47 | -------------------------------------------------------------------------------- /InheritanceJoined/src/main/java/org/thoughts/on/java/model/Book.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.Entity; 4 | 5 | @Entity 6 | public class Book extends Publication { 7 | 8 | private int numPages; 9 | 10 | public int getNumPages() { 11 | return numPages; 12 | } 13 | 14 | public void setNumPages(int numPages) { 15 | this.numPages = numPages; 16 | } 17 | 18 | @Override 19 | public int hashCode() { 20 | return 31; 21 | } 22 | 23 | @Override 24 | public boolean equals(Object obj) { 25 | if (this == obj) 26 | return true; 27 | if (obj == null) 28 | return false; 29 | if (getClass() != obj.getClass()) 30 | return false; 31 | Book other = (Book) obj; 32 | if (getId() != null) { 33 | if (!getId().equals(other.getId())) { 34 | return false; 35 | } 36 | } 37 | return true; 38 | } 39 | } -------------------------------------------------------------------------------- /InheritanceJoined/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /InheritanceJoined/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author(id, firstname, lastname, version) VALUES (1, 'Thorben', 'Janssen', 0) -------------------------------------------------------------------------------- /InheritanceJoined/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /InheritanceMappedSuperclass/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /InheritanceMappedSuperclass/src/main/java/org/thoughts/on/java/model/BlogPost.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.Entity; 4 | 5 | @Entity 6 | public class BlogPost extends Publication { 7 | 8 | private String url; 9 | 10 | public String getUrl() { 11 | return url; 12 | } 13 | 14 | public void setUrl(String url) { 15 | this.url = url; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "BlogPost [url=" + url + "]"; 21 | } 22 | 23 | @Override 24 | public int hashCode() { 25 | return 31; 26 | } 27 | 28 | @Override 29 | public boolean equals(Object obj) { 30 | if (this == obj) 31 | return true; 32 | if (obj == null) 33 | return false; 34 | if (getClass() != obj.getClass()) 35 | return false; 36 | BlogPost other = (BlogPost) obj; 37 | if (getId() != null) { 38 | if (!getId().equals(other.getId())) { 39 | return false; 40 | } 41 | } 42 | return true; 43 | } 44 | 45 | 46 | } 47 | -------------------------------------------------------------------------------- /InheritanceMappedSuperclass/src/main/java/org/thoughts/on/java/model/Book.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.Entity; 4 | 5 | @Entity 6 | public class Book extends Publication { 7 | 8 | private int numPages; 9 | 10 | public int getNumPages() { 11 | return numPages; 12 | } 13 | 14 | public void setNumPages(int numPages) { 15 | this.numPages = numPages; 16 | } 17 | 18 | @Override 19 | public int hashCode() { 20 | return 31; 21 | } 22 | 23 | @Override 24 | public boolean equals(Object obj) { 25 | if (this == obj) 26 | return true; 27 | if (obj == null) 28 | return false; 29 | if (getClass() != obj.getClass()) 30 | return false; 31 | Book other = (Book) obj; 32 | if (getId() != null) { 33 | if (!getId().equals(other.getId())) { 34 | return false; 35 | } 36 | } 37 | return true; 38 | } 39 | } -------------------------------------------------------------------------------- /InheritanceMappedSuperclass/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /InheritanceMappedSuperclass/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author(id, firstname, lastname, version) VALUES (1, 'Thorben', 'Janssen', 0) -------------------------------------------------------------------------------- /InheritanceMappedSuperclass/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /InheritanceSingleTable/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /InheritanceSingleTable/src/main/java/org/thoughts/on/java/model/BlogPost.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.DiscriminatorValue; 4 | import javax.persistence.Entity; 5 | 6 | @Entity 7 | @DiscriminatorValue("BlogPost") 8 | public class BlogPost extends Publication { 9 | 10 | private String url; 11 | 12 | public String getUrl() { 13 | return url; 14 | } 15 | 16 | public void setUrl(String url) { 17 | this.url = url; 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return "BlogPost [url=" + url + "]"; 23 | } 24 | 25 | @Override 26 | public int hashCode() { 27 | return 31; 28 | } 29 | 30 | @Override 31 | public boolean equals(Object obj) { 32 | if (this == obj) 33 | return true; 34 | if (obj == null) 35 | return false; 36 | if (getClass() != obj.getClass()) 37 | return false; 38 | BlogPost other = (BlogPost) obj; 39 | if (getId() != null) { 40 | if (!getId().equals(other.getId())) { 41 | return false; 42 | } 43 | } 44 | return true; 45 | } 46 | 47 | 48 | } 49 | -------------------------------------------------------------------------------- /InheritanceSingleTable/src/main/java/org/thoughts/on/java/model/Book.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.DiscriminatorValue; 4 | import javax.persistence.Entity; 5 | 6 | @Entity 7 | @DiscriminatorValue("Book") 8 | public class Book extends Publication { 9 | 10 | private int numPages; 11 | 12 | public int getNumPages() { 13 | return numPages; 14 | } 15 | 16 | public void setNumPages(int numPages) { 17 | this.numPages = numPages; 18 | } 19 | 20 | @Override 21 | public int hashCode() { 22 | return 31; 23 | } 24 | 25 | @Override 26 | public boolean equals(Object obj) { 27 | if (this == obj) 28 | return true; 29 | if (obj == null) 30 | return false; 31 | if (getClass() != obj.getClass()) 32 | return false; 33 | Book other = (Book) obj; 34 | if (getId() != null) { 35 | if (!getId().equals(other.getId())) { 36 | return false; 37 | } 38 | } 39 | return true; 40 | } 41 | } -------------------------------------------------------------------------------- /InheritanceSingleTable/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /InheritanceSingleTable/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author(id, firstname, lastname, version) VALUES (1, 'Thorben', 'Janssen', 0) -------------------------------------------------------------------------------- /InheritanceSingleTable/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /InheritanceTablePerClass/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /InheritanceTablePerClass/src/main/java/org/thoughts/on/java/model/BlogPost.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.Entity; 4 | 5 | @Entity 6 | public class BlogPost extends Publication { 7 | 8 | private String url; 9 | 10 | public String getUrl() { 11 | return url; 12 | } 13 | 14 | public void setUrl(String url) { 15 | this.url = url; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "BlogPost [url=" + url + "]"; 21 | } 22 | 23 | @Override 24 | public int hashCode() { 25 | return 31; 26 | } 27 | 28 | @Override 29 | public boolean equals(Object obj) { 30 | if (this == obj) 31 | return true; 32 | if (obj == null) 33 | return false; 34 | if (getClass() != obj.getClass()) 35 | return false; 36 | BlogPost other = (BlogPost) obj; 37 | if (getId() != null) { 38 | if (!getId().equals(other.getId())) { 39 | return false; 40 | } 41 | } 42 | return true; 43 | } 44 | 45 | 46 | } 47 | -------------------------------------------------------------------------------- /InheritanceTablePerClass/src/main/java/org/thoughts/on/java/model/Book.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.Entity; 4 | 5 | @Entity 6 | public class Book extends Publication { 7 | 8 | private int numPages; 9 | 10 | public int getNumPages() { 11 | return numPages; 12 | } 13 | 14 | public void setNumPages(int numPages) { 15 | this.numPages = numPages; 16 | } 17 | 18 | @Override 19 | public int hashCode() { 20 | return 31; 21 | } 22 | 23 | @Override 24 | public boolean equals(Object obj) { 25 | if (this == obj) 26 | return true; 27 | if (obj == null) 28 | return false; 29 | if (getClass() != obj.getClass()) 30 | return false; 31 | Book other = (Book) obj; 32 | if (getId() != null) { 33 | if (!getId().equals(other.getId())) { 34 | return false; 35 | } 36 | } 37 | return true; 38 | } 39 | } -------------------------------------------------------------------------------- /InheritanceTablePerClass/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /InheritanceTablePerClass/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author(id, firstname, lastname, version) VALUES (1, 'Thorben', 'Janssen', 0) -------------------------------------------------------------------------------- /InheritanceTablePerClass/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JPABootstrapping/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JPABootstrapping/src/test/java/org/thoughts/on/java/model/TestJPABootstrapping.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.Test; 9 | 10 | public class TestJPABootstrapping { 11 | 12 | Logger log = Logger.getLogger(this.getClass().getName()); 13 | 14 | @Test 15 | public void bootstrapping() { 16 | log.info("... bootstrapping ..."); 17 | 18 | EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 19 | EntityManager em = emf.createEntityManager(); 20 | em.getTransaction().begin(); 21 | 22 | em.find(Book.class, 1L); 23 | 24 | em.getTransaction().commit(); 25 | em.close(); 26 | emf.close(); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /JPABootstrapping/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2017-04-04', 'Hibernate Tips', 0); 2 | INSERT INTO book (id, publishingdate, title, version) VALUES (2, '2018-04-04', 'Another Book', 0); 3 | INSERT INTO book (id, publishingdate, title, version) VALUES (3, '2019-04-04', 'My 3rd Book', 0); 4 | -------------------------------------------------------------------------------- /JPABootstrapping/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JPAMetamodel/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JPAMetamodel/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /JPAMetamodel/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, version) VALUES (12, 'Thorben', 'Janssen', 0); 2 | 3 | INSERT INTO book (id, publishingdate, title, version) VALUES (7, '2017-04-04', 'Hibernate Tips', 0); 4 | 5 | INSERT INTO bookauthor (bookid, authorid) VALUES (7, 12); 6 | -------------------------------------------------------------------------------- /JPAMetamodel/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JPQLAdHocQuery/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JPQLAdHocQuery/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /JPQLAdHocQuery/src/test/java/org/thoughts/on/java/model/TestJpqlQuery.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | import javax.persistence.TypedQuery; 7 | 8 | import org.apache.log4j.Logger; 9 | import org.junit.After; 10 | import org.junit.Assert; 11 | import org.junit.Before; 12 | import org.junit.Test; 13 | 14 | public class TestJpqlQuery { 15 | 16 | Logger log = Logger.getLogger(this.getClass().getName()); 17 | 18 | private EntityManagerFactory emf; 19 | 20 | @Before 21 | public void init() { 22 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 23 | } 24 | 25 | @After 26 | public void close() { 27 | emf.close(); 28 | } 29 | 30 | @Test 31 | public void adHocJpqlQuery() { 32 | log.info("... adHocJpqlQuery ..."); 33 | 34 | EntityManager em = emf.createEntityManager(); 35 | em.getTransaction().begin(); 36 | 37 | TypedQuery q = em.createQuery("SELECT b FROM Book b WHERE b.id = :id", Book.class); 38 | q.setParameter("id", 1L); 39 | Book b = q.getSingleResult(); 40 | Assert.assertTrue(b instanceof Book); 41 | Assert.assertEquals(new Long(1), ((Book)b).getId()); 42 | 43 | em.getTransaction().commit(); 44 | em.close(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /JPQLAdHocQuery/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2008-05-08', 'Effective Java', 0); 2 | INSERT INTO book (id, publishingdate, title, version) VALUES (2, '2015-10-01', 'Java Persistence with Hibernate', 0); 3 | INSERT INTO book (id, publishingdate, title, version) VALUES (3, '2014-08-28', 'Java 8 in Action', 0); 4 | INSERT INTO book (id, publishingdate, title, version) VALUES (4, '2014-03-12', 'Continuous Enterprise Development in Java', 0); 5 | INSERT INTO book (id, publishingdate, title, version) VALUES (5, '2010-09-08', 'Enterprise JavaBeans 3.1', 0); 6 | INSERT INTO book (id, publishingdate, title, version) VALUES (6, '2014-04-29', 'Java Performance The Definitive Guide', 0); -------------------------------------------------------------------------------- /JPQLAdHocQuery/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JPQLConstructorExpression/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JPQLConstructorExpression/src/main/java/org/thoughts/on/java/model/BookValue.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | public class BookValue { 4 | 5 | public Long id; 6 | public String title; 7 | public String publisherName; 8 | 9 | public BookValue(Long id, String title, String publisherName) { 10 | this.id = id; 11 | this.title = title; 12 | this.publisherName = publisherName; 13 | } 14 | 15 | public Long getId() { 16 | return id; 17 | } 18 | 19 | public void setId(Long id) { 20 | this.id = id; 21 | } 22 | 23 | public String getTitle() { 24 | return title; 25 | } 26 | 27 | public void setTitle(String title) { 28 | this.title = title; 29 | } 30 | 31 | public String getPublisherName() { 32 | return publisherName; 33 | } 34 | 35 | public void setPublisherName(String publisherName) { 36 | this.publisherName = publisherName; 37 | } 38 | 39 | @Override 40 | public String toString() { 41 | return "BookValue [id=" + id + ", title=" + title + ", publisherName=" 42 | + publisherName + "]"; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /JPQLConstructorExpression/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO publisher(id, name, version) VALUES (1, 'Thoughts on Java', 0); 2 | 3 | INSERT INTO book (id, publishingdate, title, publisherid, version) VALUES (1, '2017-04-04', 'Hibernate Tips', 1, 0); -------------------------------------------------------------------------------- /JPQLConstructorExpression/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JPQLCustomFunction/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JPQLCustomFunction/src/test/resources/create-database.sql: -------------------------------------------------------------------------------- 1 | CREATE OR REPLACE FUNCTION calculate(IN x double precision, IN y double precision, OUT sum double precision) RETURNS double precision AS $BODY$ BEGIN sum = x + y; END; $BODY$ LANGUAGE plpgsql VOLATILE COST 100; 2 | ALTER FUNCTION calculate(double precision, double precision) OWNER TO postgres; 3 | 4 | CREATE TABLE book (id bigint NOT NULL, publishingdate date, title character varying(255), price double precision, version integer, CONSTRAINT book_pkey PRIMARY KEY (id)) 5 | 6 | CREATE SEQUENCE hibernate_sequence INCREMENT 1 MINVALUE 1 MAXVALUE 9223372036854775807 START 1 CACHE 1; -------------------------------------------------------------------------------- /JPQLCustomFunction/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (1, '2008-05-08', 'Effective Java', 33.0, 0); 2 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (2, '2015-10-01', 'Java Persistence with Hibernate', 42.0, 0); 3 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (3, '2014-08-28', 'Java 8 in Action', 49.0, 0); 4 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (4, '2014-03-12', 'Continuous Enterprise Development in Java', 26.0, 0); 5 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (5, '2010-09-08', 'Enterprise JavaBeans 3.1', 45.0, 0); 6 | INSERT INTO book (id, publishingdate, title, price, version) VALUES (6, '2014-04-29', 'Java Performance The Definitive Guide', 22.0, 0); -------------------------------------------------------------------------------- /JPQLCustomFunction/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JPQLDelete/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JPQLDelete/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /JPQLDelete/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JPQLNamedQuery/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JPQLNamedQuery/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /JPQLNamedQuery/src/test/java/org/thoughts/on/java/model/TestJpqlQuery.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | import javax.persistence.TypedQuery; 7 | 8 | import org.apache.log4j.Logger; 9 | import org.junit.After; 10 | import org.junit.Assert; 11 | import org.junit.Before; 12 | import org.junit.Test; 13 | 14 | public class TestJpqlQuery { 15 | 16 | Logger log = Logger.getLogger(this.getClass().getName()); 17 | 18 | private EntityManagerFactory emf; 19 | 20 | @Before 21 | public void init() { 22 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 23 | } 24 | 25 | @After 26 | public void close() { 27 | emf.close(); 28 | } 29 | 30 | @Test 31 | public void namedJpqlQuery() { 32 | log.info("... namedJpqlQuery ..."); 33 | 34 | EntityManager em = emf.createEntityManager(); 35 | em.getTransaction().begin(); 36 | 37 | TypedQuery q = em.createNamedQuery(Book.QUERY_SELECT_BY_ID, Book.class); 38 | q.setParameter(Book.PARAM_ID, 1L); 39 | Book b = q.getSingleResult(); 40 | Assert.assertTrue(b instanceof Book); 41 | Assert.assertEquals(new Long(1), ((Book)b).getId()); 42 | 43 | em.getTransaction().commit(); 44 | em.close(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /JPQLNamedQuery/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2017-04-04', 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /JPQLNamedQuery/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JPQLScalarValues/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JPQLScalarValues/src/main/java/org/thoughts/on/java/model/BookValue.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | public class BookValue { 4 | 5 | public Long id; 6 | public String title; 7 | public String publisherName; 8 | 9 | public BookValue(Long id, String title, String publisherName) { 10 | this.id = id; 11 | this.title = title; 12 | this.publisherName = publisherName; 13 | } 14 | 15 | public Long getId() { 16 | return id; 17 | } 18 | 19 | public void setId(Long id) { 20 | this.id = id; 21 | } 22 | 23 | public String getTitle() { 24 | return title; 25 | } 26 | 27 | public void setTitle(String title) { 28 | this.title = title; 29 | } 30 | 31 | public String getPublisherName() { 32 | return publisherName; 33 | } 34 | 35 | public void setPublisherName(String publisherName) { 36 | this.publisherName = publisherName; 37 | } 38 | 39 | @Override 40 | public String toString() { 41 | return "BookValue [id=" + id + ", title=" + title + ", publisherName=" 42 | + publisherName + "]"; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /JPQLScalarValues/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO publisher(id, name, version) VALUES (1, 'Thoughts on Java', 0); 2 | 3 | INSERT INTO book (id, publishingdate, title, publisherid, version) VALUES (1, '2017-04-04', 'Hibernate Tips', 1, 0); -------------------------------------------------------------------------------- /JPQLScalarValues/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JPQLUpdate/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JPQLUpdate/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /JPQLUpdate/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JoinFetch/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JoinFetch/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /JoinFetch/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, version) VALUES (1, 'Thorben', 'Janssen', 0); 2 | 3 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2008-05-08', 'Effective Java', 0); 4 | 5 | INSERT INTO bookauthor (bookid, authorid) VALUES (1, 1); -------------------------------------------------------------------------------- /JoinFetch/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /JpqlStandardFunction/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /JpqlStandardFunction/src/test/java/org/thoughts/on/java/model/TestJpqlFunction.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import java.util.List; 4 | 5 | import javax.persistence.EntityManager; 6 | import javax.persistence.EntityManagerFactory; 7 | import javax.persistence.Persistence; 8 | import javax.persistence.Query; 9 | 10 | import org.apache.log4j.Logger; 11 | import org.junit.After; 12 | import org.junit.Before; 13 | import org.junit.Test; 14 | 15 | public class TestJpqlFunction { 16 | 17 | Logger log = Logger.getLogger(this.getClass().getName()); 18 | 19 | private EntityManagerFactory emf; 20 | 21 | @Before 22 | public void init() { 23 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 24 | } 25 | 26 | @After 27 | public void close() { 28 | emf.close(); 29 | } 30 | 31 | @Test 32 | public void callSizeFunction() { 33 | log.info("... callSizeFunction ..."); 34 | 35 | EntityManager em = emf.createEntityManager(); 36 | em.getTransaction().begin(); 37 | 38 | Query q = em.createQuery("SELECT a, size(a.books) FROM Author a GROUP BY a.id"); 39 | @SuppressWarnings("unchecked") 40 | List results = q.getResultList(); 41 | 42 | for (Object[] r : results) { 43 | log.info(r[0] + " wrote " + r[1] + " books."); 44 | } 45 | 46 | em.getTransaction().commit(); 47 | em.close(); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /JpqlStandardFunction/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 Thorben Janssen 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /LogSQLStatements/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | .settings/ 3 | .project 4 | .classpath -------------------------------------------------------------------------------- /LogSQLStatements/src/test/java/org/thoughts/on/java/model/TestLogging.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | import javax.persistence.Query; 7 | 8 | import org.apache.log4j.Logger; 9 | import org.junit.After; 10 | import org.junit.Before; 11 | import org.junit.Test; 12 | 13 | public class TestLogging { 14 | 15 | Logger log = Logger.getLogger(this.getClass().getName()); 16 | 17 | private EntityManagerFactory emf; 18 | 19 | @Before 20 | public void init() { 21 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 22 | } 23 | 24 | @After 25 | public void close() { 26 | emf.close(); 27 | } 28 | 29 | @Test 30 | public void selectAuthors() { 31 | log.info("... selectAuthors ..."); 32 | 33 | EntityManager em = emf.createEntityManager(); 34 | em.getTransaction().begin(); 35 | 36 | Query q = em.createQuery("SELECT a FROM Author a WHERE a.id = :id", Author.class); 37 | q.setParameter("id", 1L); 38 | q.getSingleResult(); 39 | 40 | em.getTransaction().commit(); 41 | em.close(); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /LogSQLStatements/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, version) VALUES (1, 'Joshua', 'Bloch', 0); 2 | INSERT INTO author (id, firstname, lastname, version) VALUES (2, 'Gavin', 'King', 0); 3 | INSERT INTO author (id, firstname, lastname, version) VALUES (3, 'Christian', 'Bauer', 0); 4 | INSERT INTO author (id, firstname, lastname, version) VALUES (4, 'Gary', 'Gregory', 0); 5 | INSERT INTO author (id, firstname, lastname, version) VALUES (5, 'Raoul-Gabriel', 'Urma', 0); 6 | INSERT INTO author (id, firstname, lastname, version) VALUES (6, 'Mario', 'Fusco', 0); 7 | INSERT INTO author (id, firstname, lastname, version) VALUES (7, 'Alan', 'Mycroft', 0); 8 | INSERT INTO author (id, firstname, lastname, version) VALUES (8, 'Andrew Lee', 'Rubinger', 0); 9 | INSERT INTO author (id, firstname, lastname, version) VALUES (9, 'Aslak', 'Knutsen', 0); 10 | INSERT INTO author (id, firstname, lastname, version) VALUES (10, 'Bill', 'Burke', 0); 11 | INSERT INTO author (id, firstname, lastname, version) VALUES (11, 'Scott', 'Oaks', 0); -------------------------------------------------------------------------------- /LogSQLStatements/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /MapBasicAttributes/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /MapBasicAttributes/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /MapBasicAttributes/src/test/java/org/thoughts/on/java/model/TestAttributeMapping.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Before; 10 | import org.junit.Test; 11 | 12 | public class TestAttributeMapping { 13 | 14 | Logger log = Logger.getLogger(this.getClass().getName()); 15 | 16 | private EntityManagerFactory emf; 17 | 18 | @Before 19 | public void init() { 20 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 21 | } 22 | 23 | @After 24 | public void close() { 25 | emf.close(); 26 | } 27 | 28 | @Test 29 | public void persistAndLoad() { 30 | log.info("... persistAndLoad ..."); 31 | 32 | EntityManager em = emf.createEntityManager(); 33 | em.getTransaction().begin(); 34 | 35 | Author a = new Author(); 36 | a.setFirstName("John"); 37 | a.setLastName("Doe"); 38 | em.persist(a); 39 | 40 | em.getTransaction().commit(); 41 | em.close(); 42 | 43 | em = emf.createEntityManager(); 44 | em.getTransaction().begin(); 45 | 46 | a = em.find(Author.class, a.getId()); 47 | log.info(a); 48 | 49 | em.getTransaction().commit(); 50 | em.close(); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /MapBasicAttributes/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /MapEnumerations/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /MapEnumerations/src/main/java/org/thoughts/on/java/model/AuthorStatus.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | public enum AuthorStatus { 4 | 5 | PUBLISHED, SELF_PUBLISHED, NOT_PUBLISHED; 6 | } 7 | -------------------------------------------------------------------------------- /MapEnumerations/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 20 | 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /MapEnumerations/src/test/java/org/thoughts/on/java/model/TestEnum.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Before; 10 | import org.junit.Test; 11 | 12 | public class TestEnum { 13 | 14 | Logger log = Logger.getLogger(this.getClass().getName()); 15 | 16 | private EntityManagerFactory emf; 17 | 18 | @Before 19 | public void init() { 20 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 21 | } 22 | 23 | @After 24 | public void close() { 25 | emf.close(); 26 | } 27 | 28 | @Test 29 | public void persistAndLoad() { 30 | log.info("... persistAndLoad ..."); 31 | 32 | EntityManager em = emf.createEntityManager(); 33 | em.getTransaction().begin(); 34 | 35 | Author a = new Author(); 36 | a.setFirstName("John"); 37 | a.setLastName("Doe"); 38 | a.setStatus(AuthorStatus.PUBLISHED); 39 | 40 | em.persist(a); 41 | 42 | em.getTransaction().commit(); 43 | em.close(); 44 | 45 | em = emf.createEntityManager(); 46 | em.getTransaction().begin(); 47 | 48 | a = em.find(Author.class, a.getId()); 49 | log.info(a); 50 | 51 | em.getTransaction().commit(); 52 | em.close(); 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /MapEnumerations/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /MapGeneratedColumns/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /MapGeneratedColumns/src/test/resources/create.sql: -------------------------------------------------------------------------------- 1 | CREATE TABLE author(id bigint NOT NULL, firstname character varying(255), lastname character varying(255), lastupdate timestamp without time zone, version integer NOT NULL, CONSTRAINT author_pkey PRIMARY KEY (id)); 2 | CREATE SEQUENCE hibernate_sequence INCREMENT 1 MINVALUE 1 MAXVALUE 9223372036854775807 START 1; 3 | 4 | CREATE OR REPLACE FUNCTION sync_lastupdate() RETURNS trigger AS $$ BEGIN NEW.lastupdate := NOW(); RETURN NEW; END; $$ LANGUAGE plpgsql; 5 | 6 | CREATE TRIGGER sync_lastupdate BEFORE INSERT OR UPDATE ON author FOR EACH ROW EXECUTE PROCEDURE sync_lastupdate(); -------------------------------------------------------------------------------- /MapGeneratedColumns/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /MapNativeQueryToEntity/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /MapNativeQueryToEntity/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /MapNativeQueryToEntity/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, version) VALUES (1, 'Thorben', 'Janssen', 0); 2 | 3 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2017-04-04', 'Hibernate Tips', 0); 4 | 5 | INSERT INTO bookauthor (bookid, authorid) VALUES (1, 1); 6 | -------------------------------------------------------------------------------- /MapNativeQueryToEntity/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /MapNativeQueryToPojo/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /MapNativeQueryToPojo/src/main/java/org/thoughts/on/java/model/BookValue.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import java.util.Date; 4 | 5 | public class BookValue { 6 | 7 | private String title; 8 | private Date publishingDate; 9 | 10 | public BookValue(String title, Date publishingDate) { 11 | this.title = title; 12 | this.publishingDate = publishingDate; 13 | } 14 | 15 | public String getTitle() { 16 | return title; 17 | } 18 | 19 | public void setTitle(String title) { 20 | this.title = title; 21 | } 22 | 23 | public Date getPublishingDate() { 24 | return publishingDate; 25 | } 26 | 27 | public void setPublishingDate(Date publishingDate) { 28 | this.publishingDate = publishingDate; 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /MapNativeQueryToPojo/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /MapNativeQueryToPojo/src/test/java/org/thoughts/on/java/model/TestMapNativeQuery.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Assert; 10 | import org.junit.Before; 11 | import org.junit.Test; 12 | 13 | public class TestMapNativeQuery { 14 | 15 | Logger log = Logger.getLogger(this.getClass().getName()); 16 | 17 | private EntityManagerFactory emf; 18 | 19 | @Before 20 | public void init() { 21 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 22 | } 23 | 24 | @After 25 | public void close() { 26 | emf.close(); 27 | } 28 | 29 | @Test 30 | public void explicitMapping() { 31 | log.info("... explicitMapping ..."); 32 | 33 | EntityManager em = emf.createEntityManager(); 34 | em.getTransaction().begin(); 35 | 36 | BookValue b = (BookValue) em.createNativeQuery("SELECT b.publishingDate as date, b.title, b.id FROM book b WHERE b.id = 1", "BookValueMapping").getSingleResult(); 37 | Assert.assertTrue(b instanceof BookValue); 38 | Assert.assertEquals("Effective Java", b.getTitle()); 39 | 40 | em.getTransaction().commit(); 41 | em.close(); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /MapNativeQueryToPojo/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /MapOptionalAssociations/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /MapOptionalAssociations/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /MapOptionalAssociations/src/test/java/org/thoughts/on/java/model/TestMapOptionalAssociation.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Assert; 10 | import org.junit.Before; 11 | import org.junit.Test; 12 | 13 | public class TestMapOptionalAssociation { 14 | 15 | Logger log = Logger.getLogger(this.getClass().getName()); 16 | 17 | private EntityManagerFactory emf; 18 | 19 | @Before 20 | public void init() { 21 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 22 | } 23 | 24 | @After 25 | public void close() { 26 | emf.close(); 27 | } 28 | 29 | @Test 30 | public void testOptional() { 31 | log.info("... testOptional ..."); 32 | 33 | EntityManager em = emf.createEntityManager(); 34 | em.getTransaction().begin(); 35 | 36 | Book b = em.find(Book.class, 1L); 37 | Assert.assertTrue(b.getPublisher().isPresent()); 38 | log.info(b.getTitle() + " was published by " + b.getPublisher().get().getName()); 39 | 40 | b = em.find(Book.class, 2L); 41 | Assert.assertFalse(b.getPublisher().isPresent()); 42 | log.info(b.getTitle() + " has no publisher"); 43 | 44 | em.getTransaction().commit(); 45 | em.close(); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /MapOptionalAssociations/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO publisher(id, name, version) VALUES (1, 'Manning Publications', 0) 2 | 3 | INSERT INTO book (id, publishingdate, title, publisherid, version) VALUES (1, '2015-10-01', 'Java Persistence with Hibernate', 1, 0); 4 | INSERT INTO book (id, publishingdate, title, version) VALUES (2, '2017-02-01', 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /MapOptionalAssociations/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /MapUtilDate/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /MapUtilDate/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /MapUtilDate/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /NamedNativeQuery/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /NamedNativeQuery/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /NamedNativeQuery/src/test/java/org/thoughts/on/java/model/TestNamedNativeQuery.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | import javax.persistence.Query; 7 | 8 | import org.apache.log4j.Logger; 9 | import org.junit.After; 10 | import org.junit.Assert; 11 | import org.junit.Before; 12 | import org.junit.Test; 13 | 14 | public class TestNamedNativeQuery { 15 | 16 | Logger log = Logger.getLogger(this.getClass().getName()); 17 | 18 | private EntityManagerFactory emf; 19 | 20 | @Before 21 | public void init() { 22 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 23 | } 24 | 25 | @After 26 | public void close() { 27 | emf.close(); 28 | } 29 | 30 | @Test 31 | public void namedNativeQuery() { 32 | log.info("... namedNativeQuery ..."); 33 | 34 | EntityManager em = emf.createEntityManager(); 35 | em.getTransaction().begin(); 36 | 37 | Query q = em.createNamedQuery(Book.QUERY_SELECT_BY_ID); 38 | q.setParameter(1, 100); 39 | Book b = (Book) q.getSingleResult(); 40 | Assert.assertTrue(b instanceof Book); 41 | Assert.assertEquals(new Long(100), ((Book)b).getId()); 42 | 43 | em.getTransaction().commit(); 44 | em.close(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /NamedNativeQuery/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, version) VALUES (100, '2017-04-04', 'Hibernate Tips', 0); -------------------------------------------------------------------------------- /NamedNativeQuery/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /NativeQuery/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /NativeQuery/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /NativeQuery/src/test/java/org/thoughts/on/java/model/TestNativeQuery.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | import javax.persistence.Query; 7 | 8 | import org.apache.log4j.Logger; 9 | import org.junit.After; 10 | import org.junit.Assert; 11 | import org.junit.Before; 12 | import org.junit.Test; 13 | 14 | public class TestNativeQuery { 15 | 16 | Logger log = Logger.getLogger(this.getClass().getName()); 17 | 18 | private EntityManagerFactory emf; 19 | 20 | @Before 21 | public void init() { 22 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 23 | } 24 | 25 | @After 26 | public void close() { 27 | emf.close(); 28 | } 29 | 30 | @Test 31 | public void adHocNativeQuery() { 32 | log.info("... adHocNativeQuery ..."); 33 | 34 | EntityManager em = emf.createEntityManager(); 35 | em.getTransaction().begin(); 36 | 37 | Query q = em.createNativeQuery("SELECT * FROM book b WHERE id = ?", Book.class); 38 | q.setParameter(1, 1); 39 | Book b = (Book) q.getSingleResult(); 40 | Assert.assertTrue(b instanceof Book); 41 | Assert.assertEquals(new Long(1), ((Book)b).getId()); 42 | 43 | em.getTransaction().commit(); 44 | em.close(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /NativeQuery/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO book (id, publishingdate, title, version) VALUES (1, '2008-05-08', 'Effective Java', 0); 2 | INSERT INTO book (id, publishingdate, title, version) VALUES (2, '2015-10-01', 'Java Persistence with Hibernate', 0); 3 | INSERT INTO book (id, publishingdate, title, version) VALUES (3, '2014-08-28', 'Java 8 in Action', 0); 4 | INSERT INTO book (id, publishingdate, title, version) VALUES (4, '2014-03-12', 'Continuous Enterprise Development in Java', 0); 5 | INSERT INTO book (id, publishingdate, title, version) VALUES (5, '2010-09-08', 'Enterprise JavaBeans 3.1', 0); 6 | INSERT INTO book (id, publishingdate, title, version) VALUES (6, '2014-04-29', 'Java Performance The Definitive Guide', 0); -------------------------------------------------------------------------------- /NativeQuery/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /OrderRelationships/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /OrderRelationships/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /OrderRelationships/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /PrePersistLifecycleEvent/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /PrePersistLifecycleEvent/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 22 | 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /PrePersistLifecycleEvent/src/test/java/org/thoughts/on/java/model/TestPrePersist.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Before; 10 | import org.junit.Test; 11 | 12 | public class TestPrePersist { 13 | 14 | Logger log = Logger.getLogger(this.getClass().getName()); 15 | 16 | private EntityManagerFactory emf; 17 | 18 | @Before 19 | public void init() { 20 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 21 | } 22 | 23 | @After 24 | public void close() { 25 | emf.close(); 26 | } 27 | 28 | @Test 29 | public void testPrePersist() { 30 | log.info("... testPrePersist ..."); 31 | 32 | EntityManager em = emf.createEntityManager(); 33 | em.getTransaction().begin(); 34 | 35 | Author a = new Author(); 36 | a.setFirstName("Thorben"); 37 | a.setLastName("Janssen"); 38 | em.persist(a); 39 | 40 | em.getTransaction().commit(); 41 | em.close(); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /PrePersistLifecycleEvent/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /PrimaryKey/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /PrimaryKey/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /PrimaryKey/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /PrimaryKeyIdentityStrategy/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /PrimaryKeyIdentityStrategy/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /PrimaryKeyIdentityStrategy/src/test/java/org/thoughts/on/java/model/TestIdentityStrategy.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Before; 10 | import org.junit.Test; 11 | 12 | public class TestIdentityStrategy { 13 | 14 | Logger log = Logger.getLogger(this.getClass().getName()); 15 | 16 | private EntityManagerFactory emf; 17 | 18 | @Before 19 | public void init() { 20 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 21 | } 22 | 23 | @After 24 | public void close() { 25 | emf.close(); 26 | } 27 | 28 | @Test 29 | public void testIdentityStrategy() { 30 | log.info("... testIdentityStrategy ..."); 31 | 32 | EntityManager em = emf.createEntityManager(); 33 | em.getTransaction().begin(); 34 | 35 | Author a = new Author(); 36 | a.setFirstName("Thorben"); 37 | a.setLastName("Janssen"); 38 | 39 | log.info("Before persist"); 40 | em.persist(a); 41 | log.info("After persist"); 42 | 43 | em.getTransaction().commit(); 44 | em.close(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /PrimaryKeyIdentityStrategy/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.id.IdentifierGeneratorHelper=debug -------------------------------------------------------------------------------- /PrimaryKeyTableStrategy/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /PrimaryKeyTableStrategy/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /PrimaryKeyTableStrategy/src/test/java/org/thoughts/on/java/model/TestTableStrategy.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.junit.After; 9 | import org.junit.Before; 10 | import org.junit.Test; 11 | 12 | public class TestTableStrategy { 13 | 14 | Logger log = Logger.getLogger(this.getClass().getName()); 15 | 16 | private EntityManagerFactory emf; 17 | 18 | @Before 19 | public void init() { 20 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 21 | } 22 | 23 | @After 24 | public void close() { 25 | emf.close(); 26 | } 27 | 28 | @Test 29 | public void testTableStrategy() { 30 | log.info("... testTableStrategy ..."); 31 | 32 | EntityManager em = emf.createEntityManager(); 33 | em.getTransaction().begin(); 34 | 35 | Author a = new Author(); 36 | a.setFirstName("Thorben"); 37 | a.setLastName("Janssen"); 38 | 39 | log.info("Persist new Author entity."); 40 | em.persist(a); 41 | 42 | em.getTransaction().commit(); 43 | em.close(); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /PrimaryKeyTableStrategy/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /PrimaryKeyUUID/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /PrimaryKeyUUID/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /PrimaryKeyUUID/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace 13 | log4j.logger.org.hibernate.event.internal.AbstractSaveEventListener=trace -------------------------------------------------------------------------------- /QueryCache/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /QueryCache/src/test/java/org/thoughts/on/java/model/TestQueryCache.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | 7 | import org.apache.log4j.Logger; 8 | import org.hibernate.Session; 9 | import org.hibernate.query.Query; 10 | import org.junit.After; 11 | import org.junit.Before; 12 | import org.junit.Test; 13 | 14 | public class TestQueryCache { 15 | 16 | Logger log = Logger.getLogger(this.getClass().getName()); 17 | 18 | private EntityManagerFactory emf; 19 | 20 | @Before 21 | public void init() { 22 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 23 | } 24 | 25 | @After 26 | public void close() { 27 | emf.close(); 28 | } 29 | 30 | @Test 31 | public void selectAuthors() { 32 | log.info("... selectAuthors ..."); 33 | 34 | EntityManager em = emf.createEntityManager(); 35 | em.getTransaction().begin(); 36 | 37 | Session s = em.unwrap(Session.class); 38 | Query q = s.createQuery("SELECT a FROM Author a WHERE id = :id", Author.class); 39 | q.setParameter("id", 1L); 40 | q.setCacheable(true); 41 | log.info(q.getSingleResult()); 42 | 43 | log.info(q.getSingleResult()); 44 | 45 | em.getTransaction().commit(); 46 | em.close(); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /QueryCache/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, version) VALUES (1, 'Joshua', 'Bloch', 0); 2 | INSERT INTO author (id, firstname, lastname, version) VALUES (2, 'Gavin', 'King', 0); 3 | INSERT INTO author (id, firstname, lastname, version) VALUES (3, 'Christian', 'Bauer', 0); 4 | INSERT INTO author (id, firstname, lastname, version) VALUES (4, 'Gary', 'Gregory', 0); 5 | INSERT INTO author (id, firstname, lastname, version) VALUES (5, 'Raoul-Gabriel', 'Urma', 0); 6 | INSERT INTO author (id, firstname, lastname, version) VALUES (6, 'Mario', 'Fusco', 0); 7 | INSERT INTO author (id, firstname, lastname, version) VALUES (7, 'Alan', 'Mycroft', 0); 8 | INSERT INTO author (id, firstname, lastname, version) VALUES (8, 'Andrew Lee', 'Rubinger', 0); 9 | INSERT INTO author (id, firstname, lastname, version) VALUES (9, 'Aslak', 'Knutsen', 0); 10 | INSERT INTO author (id, firstname, lastname, version) VALUES (10, 'Bill', 'Burke', 0); 11 | INSERT INTO author (id, firstname, lastname, version) VALUES (11, 'Scott', 'Oaks', 0); -------------------------------------------------------------------------------- /QueryCache/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /QueryPagination/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /QueryPagination/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /QueryPagination/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /QueryTimeout/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /QueryTimeout/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /QueryTimeout/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | #log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # HibernateRecipes -------------------------------------------------------------------------------- /ResultsAsStreams/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /ResultsAsStreams/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /ResultsAsStreams/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /SpringBootBootstrapping/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /SpringBootBootstrapping/src/main/java/org/thoughts/on/java/DemoApplication.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java; 2 | 3 | import org.springframework.boot.SpringApplication; 4 | import org.springframework.boot.autoconfigure.SpringBootApplication; 5 | 6 | @SpringBootApplication 7 | public class DemoApplication { 8 | 9 | public static void main(String[] args) { 10 | SpringApplication.run(DemoApplication.class, args); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /SpringBootBootstrapping/src/main/resources/application.properties: -------------------------------------------------------------------------------- 1 | spring.jpa.hibernate.ddl-auto = create-drop 2 | 3 | spring.datasource.url = jdbc:postgresql://localhost:5432/recipes 4 | spring.datasource.username = postgres 5 | spring.datasource.password = postgres 6 | 7 | logging.level.org.hibernate.SQL=debug 8 | logging.level.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /SpringBootBootstrapping/src/test/java/org/thoughts/on/java/SpringBootstrappingTest.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java; 2 | 3 | import javax.persistence.EntityManager; 4 | 5 | import org.apache.log4j.Logger; 6 | import org.junit.Test; 7 | import org.junit.runner.RunWith; 8 | import org.springframework.beans.factory.annotation.Autowired; 9 | import org.springframework.boot.test.context.SpringBootTest; 10 | import org.springframework.test.annotation.Commit; 11 | import org.springframework.test.context.junit4.SpringRunner; 12 | import org.springframework.transaction.annotation.Transactional; 13 | import org.thoughts.on.java.model.Author; 14 | 15 | @RunWith(SpringRunner.class) 16 | @SpringBootTest 17 | public class SpringBootstrappingTest { 18 | 19 | Logger log = Logger.getLogger(this.getClass().getName()); 20 | 21 | @Autowired 22 | private EntityManager em; 23 | 24 | @Test 25 | @Transactional 26 | @Commit 27 | public void accessHibernateSession() { 28 | log.info("... accessHibernateSession ..."); 29 | 30 | Author a = new Author(); 31 | a.setFirstName("Thorben"); 32 | a.setLastName("Janssen"); 33 | em.persist(a); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /StoredProcedureQuery/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /StoredProcedureQuery/src/test/java/org/thoughts/on/java/model/TestNamedStoredProcedureQuery.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.EntityManager; 4 | import javax.persistence.EntityManagerFactory; 5 | import javax.persistence.Persistence; 6 | import javax.persistence.StoredProcedureQuery; 7 | 8 | import org.apache.log4j.Logger; 9 | import org.junit.After; 10 | import org.junit.Before; 11 | import org.junit.Test; 12 | 13 | public class TestNamedStoredProcedureQuery { 14 | 15 | Logger log = Logger.getLogger(this.getClass().getName()); 16 | 17 | private EntityManagerFactory emf; 18 | 19 | @Before 20 | public void init() { 21 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 22 | } 23 | 24 | @After 25 | public void close() { 26 | emf.close(); 27 | } 28 | 29 | @Test 30 | public void calculate() { 31 | 32 | EntityManager em = emf.createEntityManager(); 33 | em.getTransaction().begin(); 34 | 35 | StoredProcedureQuery query = em.createNamedStoredProcedureQuery("calculate"); 36 | query.setParameter("x", 1.23d); 37 | query.setParameter("y", 4d); 38 | query.execute(); 39 | Double sum = (Double) query.getOutputParameterValue("sum"); 40 | log.info("Calculation result: 1.23 + 4 = " + sum); 41 | 42 | em.getTransaction().commit(); 43 | em.close(); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /StoredProcedureQuery/src/test/resources/create-database.sql: -------------------------------------------------------------------------------- 1 | CREATE OR REPLACE FUNCTION calculate(IN x double precision, IN y double precision, OUT sum double precision) RETURNS double precision AS $BODY$ BEGIN sum = x + y; END; $BODY$ LANGUAGE plpgsql VOLATILE COST 100; 2 | ALTER FUNCTION calculate(double precision, double precision) OWNER TO postgres; 3 | 4 | CREATE TABLE author(id bigint NOT NULL, firstname character varying(255), lastname character varying(255), version integer NOT NULL, CONSTRAINT author_pkey PRIMARY KEY (id)); 5 | 6 | CREATE SEQUENCE hibernate_sequence INCREMENT 1 MINVALUE 1 MAXVALUE 9223372036854775807 START 1 CACHE 1; -------------------------------------------------------------------------------- /StoredProcedureQuery/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | log4j.logger.org.hibernate=info 8 | log4j.logger.org.hibernate.stat=debug 9 | log4j.logger.org.hibernate.SQL=debug -------------------------------------------------------------------------------- /TransientAttributes/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /TransientAttributes/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 20 | 22 | 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /TransientAttributes/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, dateOfBirth, version) VALUES (1, 'John', 'Doe', '12-4-1973', 0); 2 | -------------------------------------------------------------------------------- /TransientAttributes/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace -------------------------------------------------------------------------------- /Treat/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | -------------------------------------------------------------------------------- /Treat/src/main/java/org/thoughts/on/java/model/BlogPost.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.Entity; 4 | 5 | @Entity(name = "BlogPost") 6 | public class BlogPost extends Publication { 7 | 8 | @Override 9 | public boolean equals(Object obj) { 10 | if (this == obj) { 11 | return true; 12 | } 13 | if (!(obj instanceof BlogPost)) { 14 | return false; 15 | } 16 | BlogPost other = (BlogPost) obj; 17 | if (id != null) { 18 | if (!id.equals(other.id)) { 19 | return false; 20 | } 21 | } 22 | return true; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Treat/src/main/java/org/thoughts/on/java/model/Book.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import javax.persistence.Entity; 4 | 5 | @Entity(name = "Book") 6 | public class Book extends Publication { 7 | 8 | @Override 9 | public boolean equals(Object obj) { 10 | if (this == obj) { 11 | return true; 12 | } 13 | if (!(obj instanceof Book)) { 14 | return false; 15 | } 16 | Book other = (Book) obj; 17 | if (id != null) { 18 | if (!id.equals(other.id)) { 19 | return false; 20 | } 21 | } 22 | return true; 23 | } 24 | } -------------------------------------------------------------------------------- /Treat/src/main/resources/META-INF/persistence.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | Hibernate Tips 7 | org.hibernate.jpa.HibernatePersistenceProvider 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /Treat/src/test/java/org/thoughts/on/java/model/TestTreat.java: -------------------------------------------------------------------------------- 1 | package org.thoughts.on.java.model; 2 | 3 | import java.util.List; 4 | 5 | import javax.persistence.EntityManager; 6 | import javax.persistence.EntityManagerFactory; 7 | import javax.persistence.Persistence; 8 | 9 | import org.apache.log4j.Logger; 10 | import org.junit.After; 11 | import org.junit.Before; 12 | import org.junit.Test; 13 | 14 | public class TestTreat { 15 | 16 | Logger log = Logger.getLogger(this.getClass().getName()); 17 | 18 | private EntityManagerFactory emf; 19 | 20 | @Before 21 | public void init() { 22 | emf = Persistence.createEntityManagerFactory("my-persistence-unit"); 23 | } 24 | 25 | @After 26 | public void close() { 27 | emf.close(); 28 | } 29 | 30 | @SuppressWarnings("unchecked") 31 | @Test 32 | public void testTreat() { 33 | log.info("... testTreat ..."); 34 | 35 | EntityManager em = emf.createEntityManager(); 36 | em.getTransaction().begin(); 37 | 38 | List result = em 39 | .createQuery( 40 | "SELECT a, p FROM Author a JOIN a.publications p WHERE treat(p AS Book).title LIKE '%Java%'") 41 | .getResultList(); 42 | 43 | for (Object[] o : result) { 44 | log.info(o[0] + " wrote " + o[1]); 45 | } 46 | 47 | em.getTransaction().commit(); 48 | em.close(); 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /Treat/src/test/resources/data.sql: -------------------------------------------------------------------------------- 1 | INSERT INTO author (id, firstname, lastname, version) VALUES (1, 'Joshua', 'Bloch', 0); 2 | INSERT INTO author (id, firstname, lastname, version) VALUES (2, 'Gavin', 'King', 0); 3 | INSERT INTO author (id, firstname, lastname, version) VALUES (3, 'Christian', 'Bauer', 0); 4 | INSERT INTO author (id, firstname, lastname, version) VALUES (4, 'Gary', 'Gregory', 0); 5 | INSERT INTO author (id, firstname, lastname, version) VALUES (5, 'Thorben', 'Janssen', 0); 6 | INSERT INTO author (id, firstname, lastname, version) VALUES (6, 'John', 'Doe', 0); 7 | 8 | INSERT INTO publication (id, publishingdate, title, version, DTYPE) VALUES (1, '2008-05-08', 'Effective Java', 0, 'Book'); 9 | INSERT INTO publication (id, publishingdate, title, version, DTYPE) VALUES (2, '2015-10-01', 'Java Persistence with Hibernate', 0, 'Book'); 10 | INSERT INTO publication (id, publishingdate, title, version, DTYPE) VALUES (3, '2016-05-04', 'Java Weekly 32/16', 0, 'BlogPost'); 11 | 12 | INSERT INTO publicationauthor (publicationid, authorid) VALUES (1, 1); 13 | INSERT INTO publicationauthor (publicationid, authorid) VALUES (2, 2); 14 | INSERT INTO publicationauthor (publicationid, authorid) VALUES (2, 3); 15 | INSERT INTO publicationauthor (publicationid, authorid) VALUES (2, 4); 16 | INSERT INTO publicationauthor (publicationid, authorid) VALUES (3, 5); -------------------------------------------------------------------------------- /Treat/src/test/resources/log4j.properties: -------------------------------------------------------------------------------- 1 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender 2 | log4j.appender.stdout.Target=System.out 3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 4 | log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p [%c] - %m%n 5 | 6 | log4j.rootLogger=info, stdout 7 | # basic log level for all messages 8 | log4j.logger.org.hibernate=info 9 | 10 | # SQL statements and parameters 11 | log4j.logger.org.hibernate.SQL=debug 12 | log4j.logger.org.hibernate.type.descriptor.sql=trace --------------------------------------------------------------------------------