~* em JPA

Pra que serve o ~* ?

é… JPQL não é exatamente igual SQL

se o ~* (que eu não faço idéia do que é hehe) não faz parte da sintaxe do JPQL, talvez por ser específico de algum banco, creio que não vá funcionar

Algumas abreviações, são particular para cada banco.
Para JPA neste caso poderia-se utilizar LIKE

[google]LIKE JPA[/google]

ai que coisa, a gente fala pela metade

bom o ~* eu uso no Postgres (não testei em outros banco)
com esse operador ele busca tudo que for parecido com o dado informado

exemplo, tenho os dados:

Informática,
Informatica,
informática,
informatica,
oi

note que tem diferenças nas palavras essas 4 palavras para nós é uma só mas para o banco são 4, como todos sabem casesentive (acho que é assim que escreve)

ai se informar o carácter “e”, ele (banco) não vai trazer nada, mas se colocar “a”, ele vai trazer tudo, menos o oi,
legal né

Então você terá que utilizar NativeQuery. Com isso você consegue utilizar a Query específica para o banco de dados em questão.

finalmente uma luz no fim do túnel
como eu faço com NativeQuery tem algum exemplo?

jaissonduarte:

finalmente uma luz no fim do túnel
como eu faço com NativeQuery tem algum exemplo?

aqui

@Entity
@Table(name = "area")
@XmlRootElement
@NamedNativeQuery(name="findByDescricao",query="SELECT * a FROM Area a WHERE a.descricao ~* descricao", resultClass=Area.class)
/*@NamedQueries({
    @NamedQuery(name = "Area.findAll", query = "SELECT a FROM Area a"),
    @NamedQuery(name = "Area.findByCodigo", query = "SELECT a FROM Area a WHERE a.codigo = :codigo"),
    /*@NamedQuery(name = "Area.findByDescricao", query = "select * from area where descricao ~* descricao")})*/
public class Area implements Serializable {
    private static final long serialVersionUID = 1L;
    //public static final String pesquisar
   public static final String pesquisarDescricao="findByDescricao";
    @Id
    @Basic(optional = false)
    @NotNull
    @Column(name = "codigo")
    private Integer codigo;
    @Basic(optional = false)
    @NotNull
    @Size(min = 1, max = 30)
    @Column(name = "descricao")
    private String descricao;

Stateless
public class AreaDAO {

    @PersistenceContext(name = "pesquisaDocumentoPU")
    private EntityManager em;
    private Area area;

    public List<Area> pesquisar(String descricao) {
        List<Area> areas = null;
        try {
            Query query = em.createNativeQuery(Area.pesquisarDescricao);
            query.setParameter("descricao", descricao);
            areas = query.getResultList();
            return areas;
        } catch (Exception e) {
            System.out.println("erro "+e.getMessage());
        }
        return areas;
    }

e da esse erro:

Informações: erro
Internal Exception: org.postgresql.util.PSQLException: ERROR: syntax error at or near "findByDescricao"
Error Code: 0
Call: findByDescricao
Query: DataReadQuery(sql="findByDescricao")

Novamente, você tem que usar NativeQuery e não NamedQuery. NamedQuery utiliza JPQL e não tem suporte ao ~*. NativeQuery você consegue utilizar sintax do banco mesmo.

jakefrog:

Novamente, você tem que usar NativeQuery e não NamedQuery. NamedQuery utiliza JPQL e não tem suporte ao ~*. NativeQuery você consegue utilizar sintax do banco mesmo.

@NamedNativeQuery(name = "nativeTopicByDate", query = "SELECT topic.TITLE, topic.CREATION_DATE FROM TOPIC topic " +
        "WHERE topic.MODIFED_DATE=?", resultClass = Topic.class)

@Entity
@Table(name = "area")
@NamedNativeQuery(name="findByDescricao",query="SELECT * a FROM Area a WHERE a.descricao ~* descricao", resultClass=Area.class)
public class Area implements Serializable {   
    public static final String pesquisarDescricao="findByDescricao";
    .....

public  List<Topic> loadTopicByDate(Date date) {
    Query query = entityManager.createNativeQuery("nativeTopicByDate");
    query.setParameter(1, date);
 
    List<Topic> topicList = query.getResultList();
    return topicList;
    }

public List<Area> pesquisar(String descricao) {
        List<Area> areas = null;
        try {
            Query query = em.createNativeQuery(Area.pesquisarDescricao);
            query.setParameter("descricao", descricao);
            areas = query.getResultList();
            return areas;
        } catch (Exception e) {
            System.out.println("erro "+e.getMessage());
        }
        return areas;
    }

que coisa não? :D

Ops! Não vi direito. Mals! :oops:

Olha isso: SELECT * a FROM Area a WHERE a.descricao ~* descricao

troque * a por * apenas. :lol:

Outra coisa, troque de descricao para :descricao . :lol:

jakefrog:

troque * a por * apenas. :lol:
Outra coisa, troque de descricao para :descricao . :lol:

deu esse erro:
Internal Exception: org.postgresql.util.PSQLException: ERROR: syntax error at or near "findByDescricao"
Error Code: 0
Call: findByDescricao
Query: DataReadQuery(sql=“findByDescricao”)

Se você rodar SELECT * FROM Area WHERE descricao ~* :descricao direto no postgres ele funciona? Trocando o :descricao por algum valor válido?

roda que é uma beleza,

daqui a pouco vou deixar meu sistema com usabilidade -5

Tenta assim: em.createNativeQuery(“select * from area where descricao ~* :descricao”, Area.class);

Teoricamente tá tudo certo mano. O.o

package dao;

import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import modelo.Area;

@Stateless
public class AreaDAO {

    @PersistenceContext(name = "pesquisaDocumentoPU")
    private EntityManager em;
    private Area area;

    public List<Area> pesquisar(String descricao) {
        List<Area> resultado = null;
        try {
            Query consulta = em.createNativeQuery("select * from area where descricao ~* :descricao", Area.class); 
            consulta.setParameter("descricao", descricao);
            resultado = consulta.getResultList();
        } catch (Exception e) {
            System.out.println("não deu hehehes: " + e.getMessage());
        }
        return resultado;
    }
}

por que esta dando esse erro:

Informações: não deu hehehes:
Internal Exception: org.postgresql.util.PSQLException: ERROR: syntax error at or near ":"
Error Code: 0
Call: select * from area where descricao ~* :descricao
Query: ReadAllQuery(referenceClass=Area sql="select * from area where descricao ~* :descricao")

quando retiro o ":"

Informações: não deu hehehes:
Exception Description: The primary key read from the row [ArrayRecord(
=> 3
=> Informática)] during the execution of the query was detected to be null. Primary keys must not contain null.
Query: ReadAllQuery(referenceClass=Area sql="select * from area where descricao ~* descricao")

tem outra forma de fazer esse consulta?

Faz um teste: select * from area where descricao = :descricao

e passa uma descrição que exista no banco.

Caso funcione, pode ser o driver do postgres que não está reconhecendo o comando.

quando coloco o NativeQuery da esse erro:

Internal Exception: org.postgresql.util.PSQLException: ERROR: syntax error at or near "Descricao"
Error Code: 0
Call: Descricao
Query: DataReadQuery(sql=“Descricao”)

com o NamedQuery ele funciona normal

Pq seu Descricao está com D maiúsculo?

Vc colocou como eu passei?

o descricao com D maisculo é o nome da consulta da uma olhada:

@NamedNativeQuery(name="Descricao",query="SELECT * FROM Area WHERE descricao ~* descricao") @NamedQueries({ @NamedQuery(name = "Area.findAll", query = "SELECT a FROM Area a"), @NamedQuery(name = "Area.findByCodigo", query = "SELECT a FROM Area a WHERE a.codigo = :codigo"), @NamedQuery(name = "byDescricao", query = "SELECT a FROM Area a WHERE a.descricao = :descricao")}) public class Area implements Serializable { private static final long serialVersionUID = 1L; public static final String pesquisarDescricao="byDescricao"; public static final String pesquisar="Descricao";

e:

Query consulta = em.createNativeQuery(Area.pesquisar)

Não cara, lah ainda continua com o ~* @NamedNativeQuery(name="Descricao",query="SELECT * FROM Area WHERE descricao ~* descricao")Faça assim: em.createNativeQuery(“select * from area where descricao = :descricao”, Area.class);

Cara, tenta executar essa query fora de uma NamedQuery, só pra testar… tipo

Query query = session.createSQLQuery("SELECT * FROM Area WHERE descricao ~* :descricao"); query.setParameter("descricao", "o"); List result = query.list();

Se não der certo, talves o driver não suporte… mas acho dificil que seja isso… De qualquer maneira, esse comando não é equivalente a isso?

Query query = session.createSQLQuery("SELECT * FROM Area WHERE UPPER(descricao) like :descricao"); query.setParameter("descricao", "%o%".toUpperCase()); List result = query.list();

Se te servir, nem precisa ser query nativa… pode ser HQL mesmo

e ai meu
cara da onde tu tirou esse session?

tu deve ter uma sessão em algum lugar, ou um entity manager, onde tu pode executar uma sql, hql ou criteria, não?

No EntityManager o nome método é createNativeQuery

http://docs.oracle.com/javaee/6/api/javax/persistence/EntityManager.html

ricardobocchi:

No EntityManager o nome método é createNativeQuery

http://docs.oracle.com/javaee/6/api/javax/persistence/EntityManager.html

pois é eu estou tentando me virar no NativeQuery

rolou a sql?

Vc testou isso aqui?

testei sim
e deu esse erro:
Exception Description: The primary key read from the row [ArrayRecord(
=> 3
=> Informática)] during the execution of the query was detected to be null. Primary keys must not contain null.
Query: ReadAllQuery(referenceClass=Area sql=“select * from area where descricao = descricao”)

vai entender nem tenho esse dado?

mas cara estava fazendo uma gambiarras medonhas e acho que meu problema é que não estou conseguindo passar os parâmetros
enfim que bom que tu voltou

Coloca seu código como está do modo q eu falei para testar.

Tem que funcionar pois é um query normal.

Mano, novamente você não colocou os : Query consulta = em.createNativeQuery(“select * from area where descricao = descricao”, Area.class);

select * from area where descricao = :descricao
Isso aqui tem que funcionar.

só que não funciona :oops:

da esse erro:
Informações: não deu hehehes:
Internal Exception: org.postgresql.util.PSQLException: ERROR: syntax error at or near ":"
Error Code: 0
Call: select * from area where descricao = :descricao
Query: ReadAllQuery(referenceClass=Area sql=“select * from area where descricao = :descricao”)

tenta

Query consulta = em.createNativeQuery("select * from area where descricao = ?", Area.class); consulta.setParameter(1, descricao);

public List<Area> pesquisar(String descricao) {
        List<Area> resultado = null;
        try {
            //Query consulta = em.createNativeQuery("select * from area where descricao = descricao", Area.class);
            // consulta.setParameter("descricao", descricao);
            Query consulta = em.createNativeQuery("select * from area where descricao = ?", Area.class);
            consulta.setParameter(1, descricao);
            try {
                resultado = consulta.getResultList();
            } catch (Exception e) {
                System.out.println("erro 1" + e.getMessage());
            }

            return resultado;
        } catch (Exception e) {
            System.out.println("não deu hehehe: " + e.getMessage());
        }
        return resultado;
    }

erro:

Informações: erro 1
Exception Description: The primary key read from the row [ArrayRecord(
=> 2
=> jaisson)] during the execution of the query was detected to be null. Primary keys must not contain null.
Query: ReadAllQuery(referenceClass=Area sql="select * from area where descricao = ?")

Obs.: 2, jaisson, são dados do bd

tenhamos fé

Cara, deu um erro muito bizarro agora: during the execution of the query was detected to be null. Primary keys must not contain null.

Verifique seu DB se tem algum ID com campo primário null.

Caso todos os ids estejam preenchido, tenta trocar de Integer para int o seu id.
OBS.: Essa alteração pode quebrar seu código em um monte de lugar.

Olá,

Só metendo o nariz onde não fui chamado

Por que recorrer a Native Query para uma consulta simples de listagem?
Fazendo dessa forma você não vai tirar proveito da facilidade do JPA, que é justamente encapsular a conversa com o banco e tirar do desenvolvedor a preocupação com SQL.
NativeQuery foi feito para casos específicos, por exemplo quando precisar otimizar a performance de uma consulta complexa.

Se no momento não estiver com tempo suficiente para aprender a utiliza-lo, é melhor utilizar JDBC puro mesmo… do jeito que está vc tem a complexidade do JPA (reparou quantos erros está dando? esse bicho é meio sensível rsrs) sem ter as vantagens que ele proporciona!

gomesrod:

Olá,

Só metendo o nariz onde não fui chamado

Por que recorrer a Native Query para uma consulta simples de listagem?
Fazendo dessa forma você não vai tirar proveito da facilidade do JPA, que é justamente encapsular a conversa com o banco e tirar do desenvolvedor a preocupação com SQL.
NativeQuery foi feito para casos específicos, por exemplo quando precisar otimizar a performance de uma consulta complexa.

Se no momento não estiver com tempo suficiente para aprender a utiliza-lo, é melhor utilizar JDBC puro mesmo… do jeito que está vc tem a complexidade do JPA (reparou quantos erros está dando? esse bicho é meio sensível rsrs) sem ter as vantagens que ele proporciona!

essa doeu , foi direto na alma

a gente só esta tentando fazer uma consulta normal para partir para o ~* que é próprio do Postresql
entendeu amigo,

Bom, espero que vc tenha entendido que não tive nenhuma intenção de ser grosseiro, né!

Agora de volta ao assunto:
De fato, o operador ~* é mais poderoso que um simples LIKE, pelo fato de ele fazer casamento de expressões regulares. Mas nesse caso, como você só quer verificar se contém a sequência desejada (não está usando recursos específicos de expressão regular), o like pode servir perfeitamente.

Só não esqueça dos curingas % antes e depois da palavra. Assim

// Query JPQL = SELECT a FROM Area a WHERE a.descricao like :descricao query.setParameter("descricao", "%" + descricao + "%");

:oops: não, não, não que eu tenha achado “grosseiro”, é que foi engraçado, eu fazendo uma consulta simples para ver se o NativeQuery funcionava e pelo jeito não,

pois é como o ~* não funcionou eu desisti dele e estou usando o LIKE que por sinal esta bombando

valeu ao jakefrog que muito me ajudou, ao gomesrod e ao ricardobocchi
obrigado a todos mas eu vou usar o LIKE, fica para próxima o ~*

Senhor jaissonduarte, tudo bem?
Eu sumi daqui pq eu já estava sem saber oq fazer com relação ao seu problema. Geralmente nesses casos eu costumo pesquisar e escrever um post sobre o assunto.

Bem eu estou no momento escrevendo um post sobre JPA e consultas. Diversos modos de se fazer e tals. Vai ter umas 14 páginas! :shock:

Agora, só para botar lenha na fogueira, olha só o que eu acabei de fazer:

Eu mato a cobra e mostro o pau rapaz! :twisted: :twisted: :twisted:

Esse código aí é o código do meu TCC, e que estou utilizando a mesma coisa desse post: Aplicação Web Completa JSF EJB JPA JAAS.
JBoss 7, EJB + JPA.

Veja a versão do seu JDBC, a versão da implementação JPA que você está utilizando. Eu tive um erro bizarro ao declarar @NativeNamedQuery. Tente fazer do mesmo modo que eu postei ai e fale o resultado.