QueryDSL JDBC - Construire Dynamic Path sans utiliser le type Q

voix
0

J'ai l'intention de générer requête SQL par querydsl pour la construction de la chaîne dynamique. Je suis actuellement pas en utilisant JPA de données de printemps, j'ai une table Q généré, mais je ne veux pas construire la chaîne par instanciation de l'objet Q, mon exigence était de construire la requête à la volée en prenant les tables nom / q haricot nom de variable tel que défini dans la propriété de haricot Q qui sont sélectionnés par l'utilisateur au cours de l'exécution.

schéma de table Oracle:

Create table VW_OUT.AWARDS_VW
(
   GIVER_LAST_NAME varchar2(50),
   GIVER_FIRST_NAME varchar2(50)
);

Maven dep

<dependency>
            <groupId>com.querydsl</groupId>
            <artifactId>querydsl-sql</artifactId>
            <version>4.1.3</version>
        </dependency>

        <dependency>
            <groupId>com.querydsl</groupId>
            <artifactId>querydsl-sql-spring</artifactId>
            <version>4.1.3</version>
        </dependency>

Compte tenu de configuration DSL Interrogation Spring

@Configuration
public class QueryDSLConfig {

    @Autowired
    public DataSource dataSource;

    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean
    public com.querydsl.sql.Configuration querydslConfiguration() {
        SQLTemplates templates = OracleTemplates.builder()
                .printSchema()
                .quote()
                .build();
        com.querydsl.sql.Configuration configuration = new com.querydsl.sql.Configuration(templates);
        configuration.setUseLiterals(true);
        configuration.setExceptionTranslator(new SpringExceptionTranslator());

        return configuration;
    }

    @Bean
    public SQLQueryFactory queryFactory() {
        Provider<Connection> provider = new SpringConnectionProvider(dataSource);
        return new SQLQueryFactory(querydslConfiguration(), provider);
    }
}

Et l'un de type Q:

@Generated(com.querydsl.sql.codegen.MetaDataSerializer)
public class QAwardsVw extends com.querydsl.sql.RelationalPathBase<QAwardsVw> {

    private static final long serialVersionUID = 519295604;

    public static final QAwardsVw awardsVw = new QAwardsVw(AWARDS_VW);

    public final StringPath giverFirstName = createString(giverFirstName);

    public final StringPath giverLastName = createString(giverLastName);


    public QAwardsVw(String variable) {
        super(QAwardsVw.class, forVariable(variable), VW_OUT, AWARDS_VW);
        addMetadata();
    }

    public QAwardsVw(String variable, String schema, String table) {
        super(QAwardsVw.class, forVariable(variable), schema, table);
        addMetadata();
    }

    public QAwardsVw(Path<? extends QAwardsVw> path) {
        super(path.getType(), path.getMetadata(), VW_OUT, AWARDS_VW);
        addMetadata();
    }

    public QAwardsVw(PathMetadata metadata) {
        super(QAwardsVw.class, metadata, VW_OUT, AWARDS_VW);
        addMetadata();
    }

        addMetadata(giverFirstName, ColumnMetadata.named(GIVER_FIRST_NAME).withIndex(8).ofType(Types.VARCHAR).withSize(50));
        addMetadata(giverLastName, ColumnMetadata.named(GIVER_LAST_NAME).withIndex(7).ofType(Types.VARCHAR).withSize(50));   
    }
}

Mon test, en essayant de construire le chemin de genericlly, plutôt que directement à partir de la fève Q

@RunWith(SpringRunner.class)
@SpringBootTest
public class QuerydslApplicationTests {

    @Autowired
    SQLQueryFactory queryFactory;


    @Test
    public void contextLoads() {
        PathBuilder<Object> fromPath = new PathBuilder<Object>(Object.class, AWARDS_VW);
        StringPath lnamePath = Expressions.stringPath(fromPath, giverLastName);
        StringPath fnamePath = Expressions.stringPath(fromPath, giverFirstName);
        String s = queryFactory.select(fnamePath ).from(fromPath).where(lnamePath .eq(MC)).getSQL().getSQL();


        System.out.println(s);
    }
}

Ce qui me reçoit cela, le nom de la colonne n'a pas été comme nom de colonne de base de données, apparaît comme le nom de la variable de propriété de haricots, et le nom du schéma n'a pas été imprimé soit comme VW_OUT.Awards_Vw

select Awards_Vw.giverFirstName
from Awards_Vw
where Awards_Vw.giverLastName= 'MC'

Ce que je voulais était

select AWARDS_VW.giver_First_Name
    from AWARDS_VW
    where AWARDS_VW.giver_Last_Name= 'MC'

Toutefois, si j'utilise la fève Q directement, il se satisfait-il le résultat que je veux, mais je ne veux pas construire le chemin à travers instancier la fève Q comme si

QWsPersonAwardsVw p = new QWsPersonAwardsVw(p);
String s = queryFactory.select(p.giverFirstName).from(p).where(p.giverLastName.eq(MC)).getSQL().getSQL();

rendement:

select p.GIVER_FIRST_NAME
from ODS_OUT.AWARDS_VW p
where p.GIVER_LAST_NAME = 'MC'

Toute personne a des idées ou comment obtenir les métadonnées correctes? Ou utilise JPA du printemps rend ce plus facile? Le but était de générer la chaîne au cours de l'exécution afin que les noms de table / Q nom de la variable fournie par l'utilisateur ne sont pas connus à l'avance.

Je vous remercie.

Créé 07/11/2018 à 20:12
source utilisateur
Dans d'autres langues...                            

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more