We Keep Coding

#Modifying annotation in the latest Spring Data JPA versions?

I am new in Spring data JPA and when I am searching I also read Spring Data JPA #Modifying Annotation and why do we have to use #Modifying annotation for queries in Data Jpa.
After reading the accepted answer on SO page, I am confused. Now, could you pls clarify me about the following issues?
1. Should we still need to use #Modifying Annotation in the last version(s) of Spring Data JPA? If so, could you explain how should I use properly (any annotation for proper usage)?
2. I am also wondering if the similar issue is valid for #Transactional annotation? Should we also need to use it for the create, update and delete methods in Spring Boot service methods? If so, could you also give a proper usage examples for an example scenario?

from what i understand from the references, yes you have to use #Modifying for an Insert/create/delete ddl query. And you have to use #Modifying(clearAutomatically=true, flushAutomatically=true) if you are doing more update/modifying operations before or after another update/modifying operations. In the given SO he clearly stated whats happening if you are not using those two flags.
#Transactional should use for the service method/ business method. if you execute set of selections, updates, deletion in one business logic, those will be grouped and one persistence context will be used for them. so your micro query changes are visible to other micro queries with in the transaction(there can be many micro queries in your business logic code). Even if you use those above flags without using #transaction those changes wont visible to other micro queries as its work in different transaction level and which will fail your business logic .

calling function that returns ref cursor without entity in spring jpa

I am looking for a way to call function that returns ref cursor without using entity.
I found a way by using CollableStatement. if my spring boot app does not have any other entity to be handled, does it make sense not using jpa at all? and just use java.sql? meaning just connect and execute collablestatement query?
If there is any better way or my understanding is incorrect, please guide.
Thanks!

I don't think it makes sense to use JPA in your case.
JPA is mainly about CRUD functionality and it seems you are not using any of that.
I recommend to take a look at Springs JdbcTemplate, it probably fits your needs much better.

Method names too long in Spring JPA

I am using Spring Data JPA. I am using normalized DB which means, to get a full details of what i want, i have to join many tables. As you know JPA generates method name based on query. But, due to multiple joins, my method name becomes so long. sometimes, its more than 250 chars.
I am looking for #query annotation with JPA methods instead of auto generated JPA method names.
I wanna know the performance implications if i use #query annotation?
Also, please suggest any alternatives to solve my long method names keeping performance into consideration.

Whenever you write your query using Spring Data (i.e List<MyObj> findAllByName(String name)) spring data actually generates your query the same way as you'd write it using #Query annotation. So, technically speaking, boot-up time will be quicker if you write your queries as HQL or JPQL within #Query annotation. The most performant way is of course to use native queries, but it can be a pain in the ass later in the game.

Is it possible to generate a dynamic SQL query in spring boot?

I want to implement a search function with five optional variables and in every combination, so a switch/case is not a possible way. So i can't use the build in spring boot functions, because they are not dynamic (correct me if i'm wrong).
I know there is the #query annotation in the crudrepository, but there is no way to write a query with optional parameters?
I tried to write my own database access with jpa, without the help of spring boot CrudRepository.
I read in the manual this should work:
#Autowired
#PersistenceContext
private EntityManager em;
#Transactional
public List<Persons>searchPersons(params...){}
But here is the problem, my EntityManager is always null and i have no idea why. I searched some hours and found nothing.
Maybe you guys know a way to write a dynamic SQL query in Spring Boot.
Is there a way in the CrudRepository to define optional parameters for the query?
Btw i use a postgreSQL database.
Many thanks for your help.

You might want to have a look at Specifications.
See the documentation here
For that to work, your repository interface needs to implement JpaSpecificationExecutor.

You can use a custom repository (create your own interface, write one Impl class for it and extend your repository by that interface.
You should then have:
PersonRepositoryCustom
PersonRepositoryCustomImpl
Next, you implement a query, using the EntityManager autowired into your repository. You can do this by using JPQL or the JPA 2.1 Criteria API.
For each parameter, have a condition to add it to the query itself, as well as the prepared statement parameters. That way, you can build a dynamic query.
The following thread is related:
Best way to create JPA query that might contain a parameter or might not

I know this question is old but to anyone coming here interested in implementing dynamic SQL queries, check out these two blog posts, they are great.
Implementing dynamic SQL queries using Spring Data JPA
Specification and Criteria API
Writing dynamic SQL queries using Spring Data JPA repositories and
EntityManager

JPA - map entity to sql query?

I'm writing a JPA connector to a legacy sistem. The problem is, DB design in the system is.. well.. horrible.
I need to implement an entity that maps to three tables. I can do it using named sql queries, but the probem is, I have to use this entity in a OneToMany relation (this entity is on the many side). So how do I tell JPA it needs to use a specific named query with specific parameter?
And a subquestion: does any1 have any good on-line JPA documentation? I can't find anything decent :-/

I haven't actually found a way to do this with JPA. To solve problems like this I ended up using a named query.
As far as documentation, I have been using TopLink's and Hibernate's.
If you find a better way, please post it here!

Could you make a database view and then create an entity that maps onto that view? I don't know if this is possible, just a thought.

Take a look at #SecondaryTable(s). There's some examples of this in the Pro EJB 3 Java Peristance API book, page 237.