Hibernate Pure native scalar queries are not yet supported

Question

I'm working on a multimodal project and getting really frustrating error

I  get     org.hibernate.cfg.NotYetImplementedException: Pure native scalar queries are not yet supported

Caused by: org.hibernate.cfg.NotYetImplementedException: Pure native scalar queries are not yet supported
        at org.hibernate.cfg.annotations.QueryBinder.bindNativeQuery(QueryBinder.java:206) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.cfg.AnnotationBinder.bindQueries(AnnotationBinder.java:408) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.cfg.AnnotationBinder.bindClass(AnnotationBinder.java:580) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.boot.model.source.internal.annotations.AnnotationMetadataSourceProcessorImpl.processEntityHierarchies(AnnotationMetadataSourceProcessorImpl.java:248) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.boot.model.process.spi.MetadataBuildingProcess$1.processEntityHierarchies(MetadataBuildingProcess.java:230) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.boot.model.process.spi.MetadataBuildingProcess.complete(MetadataBuildingProcess.java:273) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.metadata(EntityManagerFactoryBuilderImpl.java:1224) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.build(EntityManagerFactoryBuilderImpl.java:1255) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.springframework.orm.jpa.vendor.SpringHibernateJpaPersistenceProvider.createContainerEntityManagerFactory(SpringHibernateJpaPersistenceProvider.java:58) ~[spring-orm-5.3.1.jar!/:5.3.1]
        at org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean.createNativeEntityManagerFactory(LocalContainerEntityManagerFactoryBean.java:365) ~[spring-orm-5.3.1.jar!/:5.3.1]
        at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.buildNativeEntityManagerFactory(AbstractEntityManagerFactoryBean.java:409) ~[spring-orm-5.3.1.jar!/:5.3.1]
        at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264) ~[na:na]
        at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128) ~[na:na]
        at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628) ~[na:na]

whatever I try executing - native queries, native named queries, queries, named queries... Always the same error

what am I doing wrong?

Module A :

has Spring components as well as Hibernate entity classes

Module B:

Is a SpringBoot project which imports module A

Module A pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.moduleA</groupId>
    <artifactId>A</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <jaxb-and-jaxws-lib.version>2.3.3</jaxb-and-jaxws-lib.version>
        <logging.version>2.13.3</logging.version>
        <junit-jupiter-api.version>5.7.0</junit-jupiter-api.version>
        <junit-jupiter-params.version>5.7.0</junit-jupiter-params.version>
        <mockito-junit-jupiter.version>3.5.10</mockito-junit-jupiter.version>
        <cxf-xjc-plugin.version>3.3.1</cxf-xjc-plugin.version>
        <maven.compiler.plugin>3.8.1</maven.compiler.plugin>
        <maven-surefire-plugin.version>3.0.0-M5</maven-surefire-plugin.version>
        <hibernate-core.version>5.4.23.Final</hibernate-core.version>
        <hibernate-commons-annotations.version>5.1.2.Final</hibernate-commons-annotations.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate-core.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven.compiler.plugin}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>${maven-surefire-plugin.version}</version>
            </plugin>
        </plugins>
    </build>
</project>

Module B pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.moduleB</groupId>
    <artifactId>B</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <dependency.scope>provided</dependency.scope>
        <moduleA.version>0.0.1-SNAPSHOT</moduleA.version>
        <maven.compiler.plugin>3.8.1</maven.compiler.plugin>
        <maven-surefire-plugin.version>3.0.0-M5</maven-surefire-plugin.version>
        <spring.cloud.dependencies.version>Hoxton.SR9</spring.cloud.dependencies.version>
        <spring-jms.version>5.3.1</spring-jms.version>
        <javax.json-api.version>1.0</javax.json-api.version>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.0</version>
    </parent>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud.dependencies.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>javax.json</groupId>
        <artifactId>javax.json-api</artifactId>
        <version>${javax.json-api.version}</version>
      </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>lt.lrmuitine</groupId>
            <artifactId>moduleA</artifactId>
            <version>${moduleA.version}</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven.compiler.plugin}</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>${maven-surefire-plugin.version}</version>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Classes in module A:

package com.moduleA.entity;

import org.hibernate.annotations.NamedNativeQuery;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;


@NamedNativeQuery(
        name = "Test.doTest",
        query = "select 1 from test")
@Entity
@Table(name = "test")
public class Test implements Serializable {
    @Id
    private Long loid;
}

package com.moduleA.transformer;

import org.springframework.stereotype.Component;

import javax.persistence.Tuple;
import java.util.ArrayList;
import java.util.List;

@Component
public class TestTransformer {
    public List<TestDto> transform(List<Tuple> tuples) {
        List<TestDto> testDtoList = new ArrayList<>();
        for (Tuple tuple : tuples) {
            testDtoList.add(new TestDto(tuple, 1));
        }
        return testDtoList;
    }
}

Classes in module B

package com.moduleB.configuration;

import org.springframework.context.annotation.Configuration;

@Configuration
public class ConfigModuleB {


}


package com.moduleB;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.jms.annotation.EnableJms;

@EnableJms
@SpringBootApplication(scanBasePackages = {"com.moduleB.*", "com.moduleA.*"})
@EntityScan(basePackageClasses = com.moduleA.entity.Test.class)
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

and when I try to execute this class

package com.moduleB.pxs.dao;

import org.hibernate.query.NativeQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.persistence.EntityManager;
import javax.persistence.Tuple;
import java.sql.Date;
import java.time.LocalDateTime;
import java.util.List;

@Component
public class TestDaoImpl implements TestDao {

    @Autowired
    private EntityManager em;

    @Autowired
    private TestTransformer testTransformer;

    public List<TestDto> getTestDto() {
        List<Test> tuples = em.createNamedQuery("Test.doTest",
                        Tuple.class);
        return testTransformer.transform(tuples);
    }

}

I get org.hibernate.cfg.NotYetImplementedException: Pure native scalar queries are not yet supported

Caused by: org.hibernate.cfg.NotYetImplementedException: Pure native scalar queries are not yet supported
        at org.hibernate.cfg.annotations.QueryBinder.bindNativeQuery(QueryBinder.java:206) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.cfg.AnnotationBinder.bindQueries(AnnotationBinder.java:408) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.cfg.AnnotationBinder.bindClass(AnnotationBinder.java:580) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.boot.model.source.internal.annotations.AnnotationMetadataSourceProcessorImpl.processEntityHierarchies(AnnotationMetadataSourceProcessorImpl.java:248) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.boot.model.process.spi.MetadataBuildingProcess$1.processEntityHierarchies(MetadataBuildingProcess.java:230) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.boot.model.process.spi.MetadataBuildingProcess.complete(MetadataBuildingProcess.java:273) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.metadata(EntityManagerFactoryBuilderImpl.java:1224) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.build(EntityManagerFactoryBuilderImpl.java:1255) ~[hibernate-core-5.4.23.Final.jar!/:5.4.23.Final]
        at org.springframework.orm.jpa.vendor.SpringHibernateJpaPersistenceProvider.createContainerEntityManagerFactory(SpringHibernateJpaPersistenceProvider.java:58) ~[spring-orm-5.3.1.jar!/:5.3.1]
        at org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean.createNativeEntityManagerFactory(LocalContainerEntityManagerFactoryBean.java:365) ~[spring-orm-5.3.1.jar!/:5.3.1]
        at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.buildNativeEntityManagerFactory(AbstractEntityManagerFactoryBean.java:409) ~[spring-orm-5.3.1.jar!/:5.3.1]
        at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264) ~[na:na]
        at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128) ~[na:na]
        at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628) ~[na:na]

Additional info:

break point on AbstractEntityManagerFactoryBean.java: 516 line

    Object retVal = method.invoke(getNativeEntityManagerFactory(), args);

is a point in execution that which throws this error.

Update no.1

trying to execute

getNativeEntityManagerFactory().getMetamodel().getEntities()

from AbstractEntityManagerFactoryBean.java: 516 line

gives

org.hibernate.cfg.NotYetImplementedException: Pure native scalar queries are not yet supported

Update no.2

Trying to invoke

em.getMetamodel().getEntities()

gives the same error

Update no.3

The most surprising and at the same time frustrating moment is that if I move entity classes to Springboot project everything just works...

Update no.4

It seems that this error is related to putting entity classes to a different project

Update no.5

The exact location of this error happens on

org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.java 1255 line

    final SessionFactoryBuilder sfBuilder = metadata().getSessionFactoryBuilder();

trying to execute method metadata(), however spring boot swallows this error and boots without an issue... Just moments later when trying to use entityManager it shows up...

Update no.6

Found the culprit

class: org.hibernate.cfg.annotations.QueryBinder.java;

method: public static void bindNativeQuery

line: 206

it seems that hibernate needs to know the resultClass otherwise it throws this error...

Update no.7

So, I think I found out why it throws this error... Feels like a bug from spring-boot's side, and so

when you have your entities in a separate project in your main project (spring-boot) on main class you have to put an annotation like

@EntityScan(basePackageClasses = {myEntityFromOtherProject.class}),

however it seems that functionality behind the

@EntityScan

converts

@javax.persistence.NamedNativeQuery

to

@org.hibernate.annotations.NamedNativeQuery

and happens exactly that which is described in an Update no. 6

,However when the annotation

@EntityScan

is not used and entity class is in the same project as spring-boot project then no such conversion happens and hibernate just executes the code assigned to the annotation

javax.persistence.NamedNativeQuery

which is defined in

class: org.hibernate.cfg.AnnotationBinder.java

line: 411

So, I guess it's a bug... From Spring Boot perspective.

Answer 1

And so after a long debug session I came to the conclusion that I accidentally mixed two annotations

namely

@javax.persistence.NamedNativeQuery

and

@org.hibernate.annotations.NamedNativeQuery

removing

@org.hibernate.annotations.NamedNativeQuery

fixed the issue

Answer 2

Looks like the Hibernate version you are using is very old. I see you specify a version, but I guess the version is overridden by some other dependency.