JPA

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

In the code, we write using JPA annotations, JPQL, etc... and it automatically uses ORM (Hibernate) internally. Avoid writing code that is Hibernate specific (org.hibernate)

Data Access Layer -> JPA (spec) -> Hibernate (impl engine) -> JDBC -> Database

// class level
@Entity		// this POJO is a table
@Table 		// optional; specify name and constraints on the table
@Embeddable // embed this POJO in another entity; notice that it doesn't have @Entity and thus no @Id
@AttributeOverrides @AttributeOverride	// optional; to override attribute name with column name in embeddable entity pojo

// attribute level
@Id 		// primary key
@SequenceGenerator @GeneratedValue	// generate a unique number everytime or use a sequence
@Column		// specify name and constraints on a column (nullable, unique, updatable, length, etc...)
@Embedded	// embed another POJO into this entity (will be made into same table's columns)
@Transient	// ignore the field; field isn't persisted to database

emailId in POJO = email_id in table
firstName in POJO = first_name in table

So, camelCase attribute names in POJO becomes snake_case in table column names

spring.jpa.hibernate.ddl-auto=update

create 			-- drop all existing tables and create new
create-drop		-- create tables and drop it upon program finish. used in testing.
update 			-- add schema but don't delete any prior ones
none (default)	-- make no changes to any schema
validate		-- validate existance of schema; if not found then throw exception

@Configuration
public class StudentConfig {
    @Bean
    CommandLineRunner commandLineRunner(StudentRepository repository){
        return args -> {
            Student s1 = Student.builder().name("Abhishek").email("abhishekarya102@gmail.com").build();		// pojo creation
            repository.save(s1);	// method call
        };
    }
}

T repository.save(T);		// insert into query; populates the id (primary key) on the same object and also returns it
List<T> repository.findAll();		// select * query

User user = new User();

user.getUserId();		// null here

repository.save(user);

user.getUserId();		// 1 here

@Repository
public interface StudentRepository extends JpaRepository<Student, Long> {	// <Entity type, Id type>
	List<Student> findByEmail(String email);		// all are custom methods but no need to define impl
	List<Student> findByEmailContaining(String str);		
	List<Student> findByNameNotNull();
}

// calls
repository.findByEmail("abhishek@gmail.com");
repository.findByEmailContaining("gmail.com");
repository.findByNameNotNull();

// JPQL query; based on class attrs and not column names, ?1 is first parameter

@Query("select s from Student s where s.email = ?1")
Student getStudentByEmailAddress(String email);		// method name doesn't matter now

@Query("select s.name from Student s where s.is = ?1")
String getStudentByEmailAddress(Long id);

@Query("select s from Student s where s.email = :email")
Student getStudentByEmailAddress(String email);

@Query("select s from Student s where s.email = :emailId")
Student getStudentByEmailAddress(@Param("emailId") String email);	// diff param name that arg name with @Param

@Query(
	value="SELECT * from student_table WHERE name = ?1",
	nativeQuery = true
	)

@Modifying
@Transactional
@Query(value="update student_table set name = ?1, email = ?2 where student_id=2", nativeQuery = true)
public int updateData(String name, String email);

// in Onwer entity
String ownerName;
String ownerCity;

@OneToOne
Pet pet;

// pet_pet_id column is added to Owner table as a Foreign Key

// in Pet entity
String petName;
String petType;

@OneToOne(mappedBy = "pet")
Owner owner;

// no new column created in Pet table when we map back to Owner as pet_id is already available into Owner table

// explicitly specify column to reference

// in Owner entity
@OneToOne
@JoinColumn(				// foreign key to Pet entity
	name = "pet_id",
	referencedColumnName = "petId")
private Pet pet;

// a new column called "pet_id" will be created in Owner's table referencing petId's column in Pet's table

Pet pet = Pet.builder().petName("Lucy").petType("Dog").build();
Owner owner = Owner.builder().ownerName("Abhishek").ownerCity("New Delhi").pet(pet).build();	// pet object has-a relation
repository.save(owner);

@OneToOne(cascade = CascadeType.ALL)

@OneToOne(cascade = CascadeType.ALL,
		  fetch = FetchType.LAZY)

// LAZY - fetch Owner data only on findAll() on Owner (default)
// EAGER - fetch both Owner and corresponding Pet data on findAll() on Owner

// in Pet entity
@OneToOne(mappedBy = "pet",		// attr in Owner entity defining one-to-one relation
		  optional = false)			// a Pet must have an Owner
private Owner owner;

@OneToOne(mappedBy = "pet", 
		  optional = false, 
		  cascade = CascadeType.ALL)
private Owner owner;

// in Owner entity
@OneToMany
private List<Pet> petList;

owner_id     pet_id (UNIQUE)
--------	 ------
1  				1
1 				2
1 				3

// in Owner entity
@OneToMany
@JoinColumn(
	name = "owner_id",
	referencedColumnName="ownerId"
)
private List<Pet> petList;

// in Pet entity
@ManyToOne
@JoinColumn(name = "owner_id", referencedColumnName = "ownerId")
private Owner owner;

// in Owner entity
@OneToMany(mappedBy = "owner")
private List<Pet> petList;

// in Owner entity
@ManyToMany
@JoinTable(
	name = "owner_pet_table",
	joinColumn = @JoinColumn(
		name = "owner_id",
		referencedColumnName = "ownerId"),
	inverseJoinColumn = @JoinColumn(
		name = "pet_id",
		referencedColumnName = "petId")
)
private List<Pet> petlist;

name - name of third table

joinColumn - assign the column of third table from current entity itself

inverseJoinColumn - assign the column of third table from the associated entity

For attribute type, Set<> etc.. can also be used, I have used List<> here.

// in Pet entity
@ManyToMany(mappedBy = "petList")
private List<Owner> ownerList;

Pageable firstPagewithThreeRecords = PageRequest.of(0, 3);
Pageable secondPageWithTwoRecords = PageRequest.of(1, 2);
        
List<Course> courses = courseRepository.findAll(secondPageWithTwoRecords).getContent();
long totalElements = courseRepository.findAll(secondPageWithTwoRecords).getTotalElements();
long totalPages = courseRepository.findAll(secondPageWithTwoRecords).getTotalPages();

System.out.println("totalPages = " + totalPages);	// 2
System.out.println("totalElements = " + totalElements);	// 5
System.out.println("courses = " + courses);	// 2 records on 2nd page

Pageable sortByTitle = PageRequest.of(
                        0,
                        2,
                        Sort.by("title"));		// sort by title column

Pageable sortByCreditDesc = PageRequest.of(
                        0,
                        2,
                        Sort.by("credit").descending());	// desc sort on credit column

Pageable sortByTitleAndCreditDesc = PageRequest.of(
                        0,
                        2,
                        Sort.by("title")
                        .descending()
                        .and(Sort.by("credit")));		// sorted by both title and credit in desc order
        
List<Course> courses = courseRepository.findAll(sortByTitle).getContent();

System.out.println("courses = " + courses);