1 /*
2  * Copyright 2015, The Querydsl Team (http://www.querydsl.com/team)
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  * http://www.apache.org/licenses/LICENSE-2.0
8  * Unless required by applicable law or agreed to in writing, software
9  * distributed under the License is distributed on an "AS IS" BASIS,
10  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11  * See the License for the specific language governing permissions and
12  * limitations under the License.
13  */
14 package com.querydsl.core.support;
15
16 import java.util.Arrays;
17 import java.util.Collection;
18
19 import com.querydsl.core.QueryMetadata;
20 import com.querydsl.core.types.*;
21 import com.querydsl.core.types.dsl.BooleanExpression;
22 import com.querydsl.core.types.dsl.BooleanOperation;
23 import com.querydsl.core.types.dsl.Expressions;
24
25 /**
26  * {@code FetchableSubQueryBase} extends {@link com.querydsl.core.support.FetchableQueryBase} to provide fluent Expression creation functionality
27  *
28  * @param <T>
29  * @param <Q>
30  */
31 public abstract class FetchableSubQueryBase<T, Q extends FetchableSubQueryBase<T, Q>> extends FetchableQueryBase<T, Q>
32         implements ExtendedSubQuery<T> {
33
34
35     private final SubQueryExpression<T> mixin;
36
37     @SuppressWarnings("unchecked")
38     public FetchableSubQueryBase(QueryMixin<Q> queryMixin) {
39         super(queryMixin);
40         mixin = new SubQueryExpressionImpl<T>((Class) Object.class, queryMixin.getMetadata());
41     }
42
43     @Override
44     public BooleanExpression contains(Expression<? extends T> right) {
45         return Expressions.predicate(Ops.IN, right, this);
46     }
47
48     @Override
49     public BooleanExpression contains(T constant) {
50         return contains(Expressions.constant(constant));
51     }
52
53     @Override
54     public BooleanExpression exists() {
55         QueryMetadata metadata = getMetadata();
56         if (metadata.getProjection() == null) {
57             queryMixin.setProjection(Expressions.ONE);
58         }
59         return Expressions.predicate(Ops.EXISTS, this);
60     }
61
62     @Override
63     public BooleanExpression eq(Expression<? extends T> expr) {
64         return Expressions.predicate(Ops.EQ, this, expr);
65     }
66
67     @Override
68     public BooleanExpression eq(T constant) {
69         return eq(Expressions.constant(constant));
70     }
71
72     @Override
73     public BooleanExpression ne(Expression<? extends T> expr) {
74         return Expressions.predicate(Ops.NE, this, expr);
75     }
76
77     @Override
78     public BooleanExpression ne(T constant) {
79         return ne(Expressions.constant(constant));
80     }
81
82
83     @Override
84     public BooleanExpression notExists() {
85         return exists().not();
86     }
87
88     @Override
89     public BooleanExpression lt(Expression<? extends T> expr) {
90         return Expressions.predicate(Ops.LT, this, expr);
91     }
92
93     @Override
94     public BooleanExpression lt(T constant) {
95         return lt(Expressions.constant(constant));
96     }
97
98     @Override
99     public BooleanExpression gt(Expression<? extends T> expr) {
100         return Expressions.predicate(Ops.GT, this, expr);
101     }
102
103     @Override
104     public BooleanExpression gt(T constant) {
105         return gt(Expressions.constant(constant));
106     }
107
108     @Override
109     public BooleanExpression loe(Expression<? extends T> expr) {
110         return Expressions.predicate(Ops.LOE, this, expr);
111     }
112
113     @Override
114     public BooleanExpression loe(T constant) {
115         return loe(Expressions.constant(constant));
116     }
117
118     @Override
119     public BooleanExpression goe(Expression<? extends T> expr) {
120         return Expressions.predicate(Ops.GOE, this, expr);
121     }
122
123     @Override
124     public BooleanExpression goe(T constant) {
125         return goe(Expressions.constant(constant));
126     }
127
128     @Override
129     public BooleanOperation isNull() {
130         return Expressions.booleanOperation(Ops.IS_NULL, mixin);
131     }
132
133     @Override
134     public BooleanOperation isNotNull() {
135         return Expressions.booleanOperation(Ops.IS_NOT_NULL, mixin);
136     }
137
138     @Override
139     public final int hashCode() {
140         return mixin.hashCode();
141     }
142
143     @Override
144     public final QueryMetadata getMetadata() {
145         return queryMixin.getMetadata();
146     }
147
148     @Override
149     public <R, C> R accept(Visitor<R, C> v, C context) {
150         return mixin.accept(v, context);
151     }
152
153     @SuppressWarnings("unchecked")
154     @Override
155     public Class<T> getType() {
156         Expression<?> projection = queryMixin.getMetadata().getProjection();
157         return (Class) (projection != null ? projection.getType() : Void.class);
158     }
159
160     @Override
161     public BooleanExpression in(Collection<? extends T> right) {
162         if (right.size() == 1) {
163             return eq(right.iterator().next());
164         } else {
165             return Expressions.booleanOperation(Ops.IN, mixin, ConstantImpl.create(right));
166         }
167     }
168
169     @Override
170     public BooleanExpression in(T... right) {
171         return this.in(Arrays.asList(right));
172     }
173 }
174