Database, JPA Queries, Cardinality Mappings Flashcards

Question

Which inheritance strategy provides normalized tables in JPA?

Answer 1

The JOINED strategy provides normalized tables as it separates entity attributes into individual tables based on the entity hierarchy.

Answer 2

Considerations include performance, ease of querying, maintenance, and the nature of the inheritance hierarchy when choosing an appropriate strategy.

Answer 3

Lazy fetching delays the loading of associated data until it's explicitly requested, enhancing performance by loading data only when needed.

Answer 4

@ManyToOne establishes a many-to-one relationship between entities, indicating that multiple instances of one entity can be associated with a single instance of another entity.

Answer 5

The @Entity annotation marks a Java class as a persistent entity, indicating that it is mapped to a database table.

Answer 6

In JPA, you mark a field as a primary key using the @Id annotation.

Answer 7

@DiscriminatorColumn in JPA specifies the database column that holds the discriminator value, aiding in distinguishing between different subclasses when using inheritance strategies like SINGLE_TABLE.

Answer 8

In Spring Boot, "ambiguity service" denotes a scenario where multiple beans match a specific dependency or qualifier, causing ambiguity in selecting the correct bean during dependency injection, often requiring disambiguation strategies like using @Qualifier or refining bean definitions.

Answer 9

Paging, Offset-based scrolling, Keyset-based scrolling.

Answer 10

By using the @Param annotation to give a method parameter a concrete name and bind the name in the query.

Answer 11

It dynamically inserts the entity name of the domain type associated with the repository.

Answer 12

By setting spring.jpa.properties.hibernate.use_sql_comments=true in the application.properties file.

Answer 13

It configures the fetch plan of a query by referencing a named entity graph on an entity.

Answer 14

Scrolling allows a more fine-grained approach to iterate through larger result sets in chunks.

Answer 15

Keyset-Filtering leverages built-in capabilities of the database to reduce computation and I/O requirements by using a stable sorting order and passing keys into the query to resume scrolling.

Answer 16

It triggers a query annotated to the method as an updating query instead of a selecting one.

Answer 17

By applying the @Meta annotation to repository operations, allowing custom comments to be inserted into queries.

Answer 18

It represents a chunk of query results that can be iterated through until the entire query result is consumed.

Answer 19

The three scrolling methods in Spring Data JPA for handling large query results are Paging, Offset-based scrolling, and Keyset-based scrolling.

Answer 20

The @Param annotation in Spring Data JPA is used to give method parameters a concrete name and bind that name in the query.

Answer 21

The @Query annotation is used to define custom queries in repository methods, either in JPQL (Java Persistence Query Language) or native SQL.

Answer 22

The @Modifying annotation is used in combination with the @Query annotation to declare modifying queries, indicating that the method is an updating query instead of a selecting one.

Answer 23

The @EntityGraph annotation is used to configure the fetch plan of a query result by referencing a named entity graph definition or defining ad hoc entity graphs.

Answer 24

The common query lookup strategies in Spring Data JPA include Create Query, Query Creation from Method Name, @Query Annotation, Named Queries, and Custom Implementation.

Answer 25

A JPA Named Query is a statically defined query associated with an entity using the @NamedQuery annotation or XML-based configurations, allowing queries to be referenced by their names.

Answer 26

A Named Query using annotations in JPA is defined by annotating the entity class with @NamedQuery and providing a name along with the query string, like: @Entity @NamedQuery(name = "Employee.findAll", query = "SELECT e FROM Employee e") public class Employee { // Entity fields and methods }

Answer 27

The advantages of using JPA Named Queries include enhanced maintainability, improved readability, and the ability to reuse queries throughout the application.

Answer 28

Named Queries are used in JPA by referencing the query name defined in the @NamedQuery annotation or XML configuration using EntityManager methods like createNamedQuery() or createNamedStoredProcedureQuery().

Answer 29

Yes, Named Queries can be defined using XML configurations in JPA by adding elements within the tags in the persistence.xml file.

Answer 30

Named Queries in JPA can be parameterized by using named parameters in the query string and providing corresponding parameter values when invoking the named query through EntityManager.

Answer 31

A simple LIKE expression in a JPA query is written using the % wildcard character. For example: @Query("SELECT p FROM Product p WHERE p.name LIKE %:keyword%") List findProductsByNameContaining(@Param("keyword") String keyword);

Answer 32

In JPA queries, additional functionality like specifying the position of % wildcards, applying escape characters, or combining wildcards with SpEL expressions is possible for more advanced pattern matching.

Answer 33

To perform case-insensitive searches in JPA using LIKE expressions, you can use the LOWER() or UPPER() functions in combination with the % wildcard. For instance: @Query("SELECT u FROM User u WHERE LOWER(u.username) LIKE LOWER(concat('%', :username, '%'))") List findUsersByUsernameIgnoreCase(@Param("username") String username);

Answer 34

Native Queries in JPA are SQL queries that are written in the native database query language (e.g., SQL for a specific database) and executed through the JPA EntityManager.

Answer 35

In JPA, Native Queries are executed using the createNativeQuery() method of the EntityManager. This method allows the execution of SQL queries in their native format.

Answer 36

Performance: Native Queries can sometimes offer better performance for complex or specific database operations. Full SQL Support: Allows leveraging database-specific functionalities that might not be directly supported by JPA JPQL.

Answer 37

Database Portability: Native Queries might make the application less portable across different databases due to their specific syntax. Loss of JPA Abstraction: Direct SQL queries bypass some of the benefits of JPA, such as object mapping.

Answer 38

Here's an example of executing a Native Query in JPA: Query nativeQuery = entityManager.createNativeQuery("SELECT * FROM users WHERE age > :age", User.class); nativeQuery.setParameter("age", 25); List users = nativeQuery.getResultList();

Answer 39

Yes, Native Queries in JPA can return managed entities by specifying the entity class in the createNativeQuery() method, allowing the result to be mapped to entity objects.

Answer 40

Sort sort = Sort.by(Sort.Direction.ASC, "propertyName");

Answer 41

Sort sort = Sort.by(Sort.Direction.ASC, "property1").and(Sort.by(Sort.Direction.DESC, "property2"));

Answer 42

List findByLastName(String lastName, Sort sort); This allows applying the specified Sort instance to the query method, sorting the result set accordingly.

Answer 43

Sort sort = Sort.by(Sort.Direction.ASC, "propertyName").ignoreCase();

Answer 44

You can create a Sort instance dynamically based on request parameters or conditions within your code and apply it to your query method.

Answer 45

Three main options are available: Paging. Offset-based scrolling. Keyset-based scrolling.

Answer 46

Offset-based scrolling is a lighter variant compared to paging because it does not require the total result count, allowing direct skipping to a specific result offset without needing to fetch all preceding records.

Answer 47

Keyset-based scrolling leverages database indexes to avoid the shortcomings of offset-based result retrieval. It aims to reduce computational and I/O requirements by using a stable sorting order and a set of keys to resume scrolling.

Answer 48

Scrolling can be utilized with query methods by returning a Window type that allows obtaining the scroll position to resume fetching the next window of results until the entire query result is consumed.

Answer 49

interface UserRepository extends Repository { Window findFirst10ByLastNameOrderByFirstName(String lastName, OffsetScrollPosition position); } This method declaration returns a Window using offset-based scrolling.

Answer 50

Named parameters provide a way to bind method parameters with concrete names in the query, enhancing readability and refactoring flexibility in query methods.

Answer 51

They are utilized by annotating method parameters with @Param("parameterName") and then referencing these names in the query using :parameterName.

Answer 52

The @Param annotation is used to assign a concrete name to a method parameter and bind that name in the query. It aids in disambiguating parameters in complex queries.

Answer 53

As of version 4, Spring fully supports Java 8’s parameter name discovery based on the -parameters compiler flag. By using this flag, the @Param annotation for named parameters can be omitted.

Answer 54

public interface UserRepository extends JpaRepository { @Query("select u from User u where u.firstName = :firstName and u.lastName = :lastName") User findByFirstNameAndLastName(@Param("firstName") String firstName, @Param("lastName") String lastName); } This example demonstrates the usage of named parameters (:firstName and :lastName) in a query method.

Answer 55

SpEL (Spring Expression Language) expressions in Spring Data JPA allow dynamic expression evaluation within query annotations, enabling more flexible and dynamic query constructions.

Answer 56

#{#entityName} dynamically resolves to the entity name associated with the repository. It allows query methods to refer to the entity name in a manner independent of potential future entity name changes.

Answer 57

#{#entityName} dynamically injects the entity name into the query. If an entity has set the name property in the @Entity annotation, that name is used. Otherwise, it defaults to the simple class name of the domain type.

Answer 58

public interface UserRepository extends JpaRepository { @Query("select u from #{#entityName} u where u.lastName = ?1") List findByLastName(String lastName); } In this example, #{#entityName} refers to the entity name, allowing the query to be more flexible in case the entity name changes.

Answer 59

The escape(String) method sanitizes input values, specifically escaping wildcards like _ and % in values, preventing unwanted data retrieval from like-conditions.

Answer 60

The @Modifying annotation marks a query method as modifying. It signifies that the annotated query is an update or delete operation, distinguishing it from a selecting query.

Answer 61

Upon executing a modifying query, the EntityManager might retain outdated entities. By default, it doesn't automatically clear the EntityManager to avoid dropping non-flushed changes. However, this can be configured by setting the clearAutomatically attribute of @Modifying to true.

Answer 62

No, the @Modifying annotation is only necessary for query methods explicitly annotated with @Query. Derived query methods or custom methods, not annotated with @Query, do not require this annotation.

Answer 63

The @Query annotation helps define custom query methods that execute modifying operations such as updates or deletes in Spring Data JPA.

Answer 64

Spring Data JPA supports derived delete queries, allowing developers to avoid explicitly declaring JPQL queries. For instance: interface UserRepository extends Repository { void deleteByRoleId(long roleId); } In this example, the method deleteByRoleId() generates a delete query based on the method name.

Answer 65

Scrolling refers to a technique for processing large query results efficiently without loading the entire dataset into memory. It allows the retrieval of results in manageable chunks or windows.

Answer 66

The methods available for consuming large query results are: Paging Offset-based scrolling Keyset-based scrolling

Answer 67

Offset-based scrolling skips a defined number of results before retrieving a chunk of data. It is similar to pagination but does not require the total result count. However, it might still require materializing the full query result before returning the relevant chunk.

Answer 68

Keyset-based scrolling, also known as keyset pagination, leverages database indexes to retrieve subsequent chunks of data. It uses a stable sorting order and a set of keys from the last entity fetched to resume fetching from that position. This approach aims to reduce computation and I/O requirements for individual queries.

Answer 69

Spring Data JPA offers methods like findFirst10By...() that can be combined with scroll positions like OffsetScrollPosition or KeysetScrollPosition to retrieve and navigate through query results using scrolling techniques.

Answer 70

Fetch- and LoadGraphs in Spring Data JPA allow the specification of the fetch plan for entity queries. They help define how related entities should be loaded or fetched along with the primary entity.

Answer 71

In Spring Data JPA entities, Fetch- and LoadGraphs are configured using the @NamedEntityGraph annotation. This annotation references a named entity graph definition that specifies how related entities should be loaded.

Answer 72

The @NamedEntityGraph annotation allows the definition of a named entity graph on an entity. It specifies the attribute nodes (related entities) that need to be fetched along with the primary entity.

Answer 73

In a Spring Data JPA repository query method, you can reference a named entity graph using the @EntityGraph annotation. This annotation is applied to the query method and specifies the named entity graph (value) and the type of fetching (type).

Answer 74

You can define ad hoc entity graphs in Spring Data JPA repository query methods using the @EntityGraph annotation directly within the query method. This annotation specifies the attribute paths (related entities) to be fetched without needing an explicitly named entity graph.

Answer 75

Query hints in Spring Data JPA are additional instructions or directives provided to the underlying database to optimize query execution or alter the behavior of query execution plans.

Answer 76

In Spring Data JPA, query hints are applied using the @QueryHints annotation. This annotation is placed on the repository query method and takes JPA @QueryHint annotations as values to specify the hints.

Answer 77

The @QueryHints annotation in Spring Data JPA takes two parameters: value: An array of JPA @QueryHint annotations specifying the hints to be applied. forCounting: A boolean flag to potentially disable hints for the count query triggered during pagination.

Answer 78

To potentially disable hints for the count query triggered during pagination in Spring Data JPA, set the forCounting parameter of the @QueryHints annotation to false.

Answer 79

Query hints in Spring Data JPA serve to influence the execution plans of database queries, potentially optimizing performance, altering caching behavior, or guiding the query planner in selecting better query execution strategies.

Answer 80

The EntityManager is the primary interface through which applications interact with the persistence context in JPA. It manages the lifecycle of entities, provides methods for querying the database, and persists changes to entities.

Answer 81

The EntityManager in JPA is responsible for: Managing entity lifecycle (persisting, merging, removing, and refreshing entities) Executing queries against the database Maintaining the persistence context

Answer 82

In JPA, the EntityManager is typically obtained using the EntityManagerFactory. An instance of the EntityManager is acquired by calling the createEntityManager() method on the EntityManagerFactory.

Answer 83

The persistence context in the EntityManager is a collection of entity instances that are currently being managed. It tracks changes to these entities and synchronizes them with the underlying database during specific points, like transaction commits.

Answer 84

EntityManager interacts with entities using various methods: persist(Object entity): Adds a new entity to the persistence context. merge(Object entity): Updates the state of a detached entity. remove(Object entity): Marks an entity for removal from the persistence context. find(Class entityClass, Object primaryKey): Retrieves an entity by its primary key. createQuery(String jpql): Creates a query to retrieve entities based on JPQL.