Comment obtenir une requête entièrement matérialisée à partir de querydsl

Je suis en train d'utiliser querydsl pour la construction de requêtes dynamiques pour la dynamique des schémas. Je suis en train de devenir la requête au lieu d'avoir à l'exécuter.

Jusqu'à présent j'ai été confronté à deux problèmes:
- Le schéma.tableau de notation est absent. Au lieu de cela, je seulement obtenir le nom de la table.
- J'ai été en mesure d'obtenir la requête, mais il sépare les variables et met '?' à la place qui est compréhensible. Mais je me demande si il est possible d'obtenir entièrement matérialisé requête, y compris les paramètres.

Voici mon essai en cours et le résultat(je suis en utilisant MySQLTemplates pour créer la configuration):

private SQLTemplates templates = new MySQLTemplates();
private Configuration configuration = new Configuration(templates); 

String table = "sometable"
Path<Object> userPath = new PathImpl<Object>(Object.class, table);
StringPath usernamePath = Expressions.stringPath(userPath, "username");
NumberPath<Long> idPath = Expressions.numberPath(Long.class, userPath, "id");
SQLQuery sqlQuery = new SQLQuery(connection, configuration)
  .from(userPath).where(idPath.eq(1l)).limit(10);
String query = sqlQuery.getSQL(usernamePath).getSQL();
return query;

Et ce que je reçois est:

select sometable.username
from sometable
where sometable.id = ?
limit ?

Ce que je voulais faire était:

select sometable.username
from someschema.sometable
where sometable.id = ?
limit ?

Mise à jour: je suis venu avec ce genre de hack pour obtenir les paramètres matérialisé(Pas idéal et aimerais meilleure solution), Mais encore ne pouvait pas obtenir de Schéma.Tableau de notation de travail:

Hack suit. S'il vous plaît suggérer nettoyant QueryDsl façon de le faire:

String query = cleanQuery(sqlQuery.getSQL(usernamePath));

private String cleanQuery(SQLBindings bindings){
    String query = bindings.getSQL();
    for (Object binding : bindings.getBindings()) {
        query = query.replaceFirst("\\?", binding.toString());
    }
    return query;
}

source d'informationauteur MickJ

9

Pour permettre schéma d'impression utilisez le modèle suivant
```
SQLTemplates templates = MySQLTemplates.builder()
    .printSchema()
    .build();
```
SQLTemplates sous-classes ont été utilisés avant, mais depuis quelques temps, le générateur de modèle est le moyen officiel de personnaliser les modèles de http://www.querydsl.com/static/querydsl/3.3.1/reference/html/ch02s03.html#d0e904

Et de permettre directe la sérialisation des littéraux utilisation
```
//configuration level
configuration.setUseLiterals(true);

//query level
configuration.setUseLiterals(true);
```
Voici un exemple complet
```
//configuration
SQLTemplates templates = MySQLTemplates.builder()
    .printSchema()
    .build();
Configuration configuration = new Configuration(templates);

//querying
SQLQuery sqlQuery = new SQLQuery(connection, configuration)
    .from(userPath).where(idPath.eq(1l)).limit(10);
sqlQuery.setUseLiterals(true);    
String query = sqlQuery.getSQL(usernamePath).getSQL();
```
Si vous voulez simplement la chaîne de requête SQL, déplacer setUseLiterals de requête de configuration.

Concernant l'utilisation de Querydsl expressions l'utilisation de la génération de code comme décrite ici est conseillé http://www.querydsl.com/static/querydsl/3.3.1/reference/html/ch02s03.html

Il fera de votre code typesafe, compact et lisible.

Si vous voulez essayer Querydsl sans génération de code, vous pouvez remplacer
```
Path<Object> userPath = new PathImpl<Object>(Object.class, variable);
```
avec
```
Path<Object> userPath = new RelationalPathBase<Object>(Object.class, variable, schema, table);
```
0

Lorsque l'on travaille avec QueryDSL, vous devez fournir un modèle pour la base de données de la plate-forme pour construire la requête. Je vois que vous êtes déjà est ce que font ici:
```
private SQLTemplates templates = new MySQLTemplates();
private Configuration configuration = new Configuration(templates); 
```
Pour rendre le nom de schéma apparaissent dans la requête générée, le seul moyen que j'ai trouvé à faire c'est (il peut y avoir un moyen plus simple) est d'étendre le modèle de la classe et de l'appeler explicitement this.setPrintSchema(true); à l'intérieur du constructeur. Voici une classe qui doit fonctionner MySql:
```
import com.mysema.query.sql.MySQLTemplates;

public class NewMySqlTemplates extends MySQLTemplates {

    public NewMySqlTemplates() {
        super('\\', false);
    }

    public NewMySqlTemplates(boolean quote) {
        super('\\', quote);
    }

    public NewMySqlTemplates(char escape, boolean quote) {
        super(escape, quote);
        this.setPrintSchema(true);
    }

}
```
Il suffit ensuite d'utiliser cette NewMySqlTemplates classe à la place de la MySQLTemplates classe comme ceci:
```
private SQLTemplates templates = new NewMySQLTemplates();
private Configuration configuration = new Configuration(templates); 
```
J'ai ce travail à l'aide de PostgresTemplates, donc j'ai peut-être une faute de frappe ou erreur dans le NewMySqlTemplates classe au-dessus, mais vous devriez être en mesure de l'obtenir pour fonctionner. Bonne chance!

Vous devez vous connecter pour publier un commentaire.