name
stringlengths 12
178
| code_snippet
stringlengths 8
36.5k
| score
float64 3.26
3.68
|
|---|---|---|
querydsl_JTSSurfaceExpression_area_rdh
|
/**
* The area of this Surface, as measured in the spatial reference system of this Surface.
*
* @return area
*/
public NumberExpression<Double> area() {
if (area == null) {
area = Expressions.numberOperation(Double.class, SpatialOps.AREA, mixin);
}
return area;
}
| 3.26 |
querydsl_JTSSurfaceExpression_centroid_rdh
|
/**
* The mathematical centroid for this Surface as a Point. The result is not guaranteed to
* be on this Surface.
*
* @return centroid
*/
public JTSPointExpression<Point> centroid() {
if
(centroid == null) {
centroid = JTSGeometryExpressions.pointOperation(SpatialOps.CENTROID, mixin);
}
return centroid;
}
| 3.26 |
querydsl_JTSSurfaceExpression_pointOnSurface_rdh
|
/**
* A Point guaranteed to be on this Surface.
*
* @return point on surface
*/
public JTSPointExpression<Point> pointOnSurface() {if (pointOnSurface == null) {pointOnSurface = JTSGeometryExpressions.pointOperation(SpatialOps.POINT_ON_SURFACE, mixin);
}
return pointOnSurface;
}
| 3.26 |
querydsl_JTSGeometryExpressions_collect_rdh
|
/**
* Return a specified ST_Geometry value from a collection of other geometries.
*
* @param expr1
* geometry
* @param expr2
* other geometry
* @return geometry collection
*/
public static JTSGeometryExpression<?> collect(Expression<? extends Geometry> expr1, Expression<? extends Geometry> expr2) {
return geometryOperation(SpatialOps.COLLECT2, expr1, expr2);
}
| 3.26 |
querydsl_JTSGeometryExpressions_asJTSGeometry_rdh
|
/**
* Create a new JTSGeometryExpression
*
* @param value
* Geometry
* @return new JTSGeometryExpression
*/
public static <T extends Geometry> JTSGeometryExpression<T> asJTSGeometry(T value) {
return asJTSGeometry(Expressions.constant(value));
}
| 3.26 |
querydsl_JTSGeometryExpressions_dwithin_rdh
|
/**
* Returns true if the geometries are within the specified distance of one another.
* For geometry units are in those of spatial reference and For geography units are in meters.
*
* @param expr1
* geometry
* @param expr2
* other geometry
* @param distance
* distance
* @return true, if with distance of each other
*/
public static BooleanExpression dwithin(Expression<? extends Geometry> expr1,
Expression<? extends
Geometry> expr2, double distance)
{
return Expressions.booleanOperation(SpatialOps.DWITHIN, expr1, expr2, ConstantImpl.create(distance));
}
| 3.26 |
querydsl_JTSGeometryExpressions_setSRID_rdh
|
/**
* Sets the SRID on a geometry to a particular integer value.
*
* @param expr
* geometry
* @param srid
* SRID
* @param <T>
* @return geometry
*/
public static <T extends Geometry> JTSGeometryExpression<T> setSRID(Expression<T> expr, int srid) {
return geometryOperation(expr.getType(), SpatialOps.SET_SRID, expr, ConstantImpl.create(srid));
}
| 3.26 |
querydsl_JTSGeometryExpressions_lineStringOperation_rdh
|
/**
* Create a new LineString operation expression
*
* @param op
* operator
* @param args
* arguments
* @return operation expression
*/
public static JTSLineStringExpression<LineString> lineStringOperation(Operator op, Expression<?>... args) {
return
new JTSLineStringOperation<LineString>(LineString.class, op, args);
}
| 3.26 |
querydsl_JTSGeometryExpressions_translate_rdh
|
/**
* Translates the geometry to a new location using the numeric parameters as offsets.
*
* @param expr
* geometry
* @param deltax
* x offset
* @param deltay
* y offset
* @param deltaz
* z offset
* @param <T>
* @return geometry
*/
public static <T extends Geometry>
JTSGeometryExpression<T> translate(Expression<T> expr, float deltax, float deltay, float deltaz) {
return geometryOperation(expr.getType(), SpatialOps.TRANSLATE2, expr, ConstantImpl.create(deltax), ConstantImpl.create(deltay), ConstantImpl.create(deltaz));}
| 3.26 |
querydsl_JTSGeometryExpressions_geometryOperation_rdh
|
/**
* Create a new Geometry operation expression
*
* @param op
* operator
* @param args
* arguments
* @return operation expression
*/
public static <T extends Geometry> JTSGeometryExpression<T> geometryOperation(Class<? extends T> type, Operator op, Expression<?>... args) {
return new JTSGeometryOperation<T>(type, op, args);
}
| 3.26 |
querydsl_JTSGeometryExpressions_fromText_rdh
|
/**
* Return a specified ST_Geometry value from Well-Known Text representation (WKT).
*
* @param text
* WKT form
* @return geometry
*/
public static JTSGeometryExpression<?> fromText(Expression<String> text) {
return geometryOperation(SpatialOps.GEOM_FROM_TEXT, text);
}
| 3.26 |
querydsl_JTSGeometryExpressions_asEWKT_rdh
|
/**
* Return a specified ST_Geometry value from Extended Well-Known Text representation (EWKT).
*
* @param expr
* geometry
* @return EWKT form
*/
public static StringExpression asEWKT(JTSGeometryExpression<?> expr) {
return Expressions.stringOperation(SpatialOps.AS_EWKT, expr);
}
| 3.26 |
querydsl_JTSGeometryExpressions_ymin_rdh
|
/**
* Returns Y minima of a bounding box 2d or 3d or a geometry.
*
* @param expr
* geometry
* @return y minima
*/
public static NumberExpression<Double> ymin(JTSGeometryExpression<?> expr) {
return Expressions.numberOperation(Double.class, SpatialOps.YMIN, expr);
}
| 3.26 |
querydsl_JTSGeometryExpressions_ymax_rdh
|
/**
* Returns Y maxima of a bounding box 2d or 3d or a geometry.
*
* @param expr
* geometry
* @return y maxima
*/
public static NumberExpression<Double> ymax(JTSGeometryExpression<?> expr) {
return Expressions.numberOperation(Double.class, SpatialOps.YMAX, expr);
}
| 3.26 |
querydsl_JTSGeometryExpressions_pointOperation_rdh
|
/**
* Create a new Point operation expression
*
* @param op
* operator
* @param args
* arguments
* @return operation expression
*/
public static JTSPointExpression<Point> pointOperation(Operator op, Expression<?>... args) {
return new JTSPointOperation<Point>(Point.class, op, args);
}
| 3.26 |
querydsl_JTSGeometryExpressions_polygonOperation_rdh
|
/**
* Create a new Polygon operation expression
*
* @param op
* operator
* @param args
* arguments
* @return operation expression
*/
public static JTSPolygonExpression<Polygon> polygonOperation(Operator op, Expression<?>... args) {
return new JTSPolygonOperation<Polygon>(Polygon.class, op, args);
}
| 3.26 |
querydsl_JTSGeometryExpressions_xmin_rdh
|
/**
* Returns X minima of a bounding box 2d or 3d or a geometry.
*
* @param expr
* geometry
* @return x minima
*/
public static NumberExpression<Double> xmin(JTSGeometryExpression<?> expr) {
return Expressions.numberOperation(Double.class, SpatialOps.XMIN, expr);
}
| 3.26 |
querydsl_JTSGeometryExpressions_xmax_rdh
|
/**
* Returns X maxima of a bounding box 2d or 3d or a geometry.
*
* @param expr
* geometry
* @return x maxima
*/
public static NumberExpression<Double> xmax(JTSGeometryExpression<?> expr) {
return Expressions.numberOperation(Double.class, SpatialOps.XMAX, expr);
}
| 3.26 |
querydsl_JTSGeometryExpressions_extent_rdh
|
/**
* Returns the bounding box that bounds rows of geometries.
*
* @param collection
* geometry collection
* @return geometry collection
*/
public static JTSGeometryExpression<?> extent(Expression<? extends GeometryCollection> collection) {
return geometryOperation(SpatialOps.EXTENT, collection);
}
| 3.26 |
querydsl_GeometryExpression_distance_rdh
|
/**
* Returns the shortest distance between any two Points in the two geometric objects as
* calculated in the spatial reference system of this geometric object. Because the geometries
* are closed, it is possible to find a point on each geometric object involved, such that the
* distance between these 2 points is the returned distance between their geometric objects.
*
* @param geometry
* other geometry
* @return distance between this and the other geometry
*/
public NumberExpression<Double> distance(Expression<? extends Geometry> geometry) {
return Expressions.numberOperation(Double.class, SpatialOps.DISTANCE, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_intersects_rdh
|
/**
* Returns 1 (TRUE) if this geometric object “spatially intersects” anotherGeometry.
*
* @param geometry
* other geometry
* @return true, if intersects
*/
public BooleanExpression intersects(Expression<? extends Geometry> geometry) {
return Expressions.booleanOperation(SpatialOps.INTERSECTS, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_asBinary_rdh
|
/**
* Exports this geometric object to a specific Well-known Binary Representation of
* Geometry.
*
* @return binary representation
*/
public SimpleExpression<byte[]> asBinary() {
if (binary == null) {binary = Expressions.operation(byte[].class, SpatialOps.AS_BINARY, mixin);
}
return binary;
}
| 3.26 |
querydsl_GeometryExpression_touches_rdh
|
/**
* Returns 1 (TRUE) if this geometric object “spatially touches” anotherGeometry.
*
* @param geometry
* other geometry
* @return true, if touches
*/
public BooleanExpression touches(Expression<? extends Geometry> geometry) {
return Expressions.booleanOperation(SpatialOps.TOUCHES, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_distanceSpheroid_rdh
|
// TODO maybe move out
public NumberExpression<Double> distanceSpheroid(Expression<?
extends Geometry> geometry) {
return Expressions.numberOperation(Double.class, SpatialOps.DISTANCE_SPHEROID, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_within_rdh
|
/**
* Returns 1 (TRUE) if this geometric object is “spatially within” anotherGeometry.
*
* @param geometry
* other geometry
* @return true, if within
*/
public BooleanExpression within(Expression<? extends Geometry> geometry) {
return Expressions.booleanOperation(SpatialOps.WITHIN, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_crosses_rdh
|
/**
* Returns 1 (TRUE) if this geometric object “spatially crosses’ anotherGeometry.
*
* @param geometry
* other geometry
* @return true, if crosses
*/
public BooleanExpression crosses(Expression<? extends Geometry> geometry) {
return Expressions.booleanOperation(SpatialOps.CROSSES, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_symDifference_rdh
|
/**
* Returns a geometric object that represents the
* Point set symmetric difference of this geometric object with anotherGeometry.
*
* @param geometry
* other geometry
* @return symmetric difference between this and the geometry
*/
public GeometryExpression<Geometry> symDifference(Expression<? extends Geometry> geometry) {return GeometryExpressions.geometryOperation(SpatialOps.SYMDIFFERENCE, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_intersection_rdh
|
/**
* Returns a geometric object that represents the Point set intersection of this geometric
* object with anotherGeometry.
*
* @param geometry
* other geometry
* @return intersection of this and the other geometry
*/
public GeometryExpression<Geometry> intersection(Geometry geometry) {
return intersection(ConstantImpl.create(geometry));
}
| 3.26 |
querydsl_GeometryExpression_difference_rdh
|
/**
* Returns a geometric object that represents the Point
* set difference of this geometric object with anotherGeometry.
*
* @param geometry
* other geometry
* @return difference between this and the other geometry
*/
public GeometryExpression<Geometry> difference(Expression<? extends Geometry> geometry) {
return GeometryExpressions.geometryOperation(SpatialOps.DIFFERENCE, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_asText_rdh
|
/**
* Exports this geometric object to a specific Well-known Text Representation of Geometry.
*
* @return text representation
*/
public StringExpression asText() {
if (text == null) {
text = Expressions.stringOperation(SpatialOps.AS_TEXT, mixin);
}
return text;
}
| 3.26 |
querydsl_GeometryExpression_disjoint_rdh
|
/**
* Returns 1 (TRUE) if this geometric object is “spatially disjoint” from anotherGeometry.
*
* @param geometry
* other geometry
* @return true, if disjoint
*/
public BooleanExpression disjoint(Expression<? extends Geometry> geometry) {
return Expressions.booleanOperation(SpatialOps.DISJOINT, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_buffer_rdh
|
/**
* Returns a geometric object that represents all Points whose distance from this geometric
* object is less than or equal to distance. Calculations are in the spatial reference system
* of this geometric object. Because of the limitations of linear interpolation, there will
* often be some relatively small error in this distance, but it should be near the resolution
* of the coordinates used.
*
* @param distance
* distance
* @return buffer
*/
public GeometryExpression<Geometry> buffer(double distance)
{
return GeometryExpressions.geometryOperation(SpatialOps.BUFFER, mixin, ConstantImpl.create(distance));
}
| 3.26 |
querydsl_GeometryExpression_srid_rdh
|
/**
* Returns the Spatial Reference System ID for this geometric object. This will normally be a
* foreign key to an index of reference systems stored in either the same or some other datastore.
*
* @return SRID
*/
public NumberExpression<Integer> srid() {
if (srid == null) {
srid = Expressions.numberOperation(Integer.class, SpatialOps.SRID, mixin);
}
return
srid;
}
| 3.26 |
querydsl_GeometryExpression_distanceSphere_rdh
|
// TODO maybe move out
public NumberExpression<Double> distanceSphere(Expression<? extends Geometry> geometry) {
return Expressions.numberOperation(Double.class, SpatialOps.DISTANCE_SPHERE, mixin,
geometry);
}
| 3.26 |
querydsl_GeometryExpression_envelope_rdh
|
/**
* The minimum bounding box for this Geometry, returned as a Geometry. The
* polygon is defined by the corner points of the bounding box [(MINX, MINY), (MAXX, MINY), (MAXX, MAXY),
* (MINX, MAXY), (MINX, MINY)]. Minimums for Z and M may be added. The simplest representation of an
* Envelope is as two direct positions, one containing all the minimums, and another all the maximums. In some
* cases, this coordinate will be outside the range of validity for the Spatial Reference System.
*
* @return envelope
*/
public GeometryExpression<Geometry> envelope() {
if (envelope == null) {
envelope = GeometryExpressions.geometryOperation(SpatialOps.ENVELOPE, mixin);}
return envelope;
}
| 3.26 |
querydsl_GeometryExpression_relate_rdh
|
/**
* Returns 1 (TRUE) if this geometric object is spatially related to anotherGeometry by testing
* for intersections between the interior, boundary and exterior of the two geometric objects
* as specified by the values in the intersectionPatternMatrix. This returns FALSE if all the
* tested intersections are empty except exterior (this) intersect exterior (another).
*
* @param geometry
* other geometry
* @param matrix
* matrix
* @return true, if this geometry is spatially related to the other
*/
public BooleanExpression relate(Expression<? extends Geometry> geometry, String matrix) {
return Expressions.booleanOperation(SpatialOps.RELATE, mixin, geometry, ConstantImpl.create(matrix));
}
| 3.26 |
querydsl_GeometryExpression_dimension_rdh
|
/**
* The inherent dimension of this geometric object, which must be less than or equal
* to the coordinate dimension. In non-homogeneous collections, this will return the largest topological
* dimension of the contained objects.
*
* @return dimension
*/
public NumberExpression<Integer> dimension() {
if (dimension == null) {
dimension
= Expressions.numberOperation(Integer.class, SpatialOps.DIMENSION, mixin);
}
return dimension;}
| 3.26 |
querydsl_GeometryExpression_isEmpty_rdh
|
/**
* Returns 1 (TRUE) if this geometric object is the empty Geometry. If true, then this
* geometric object represents the empty point set ∅ for the coordinate space.
*
* @return empty
*/
public BooleanExpression isEmpty() {
if (empty == null) {empty = Expressions.booleanOperation(SpatialOps.IS_EMPTY, mixin);
}
return empty;
}
| 3.26 |
querydsl_GeometryExpression_geometryType_rdh
|
/**
* Returns the name of the instantiable subtype of Geometry of which this
* geometric object is an instantiable member. The name of the subtype of Geometry is returned as a string.
*
* @return geometry type
*/
public StringExpression geometryType() {
if (geometryType == null) {
geometryType = Expressions.stringOperation(SpatialOps.GEOMETRY_TYPE, mixin);
}
return geometryType;
}
| 3.26 |
querydsl_GeometryExpression_eq_rdh
|
/* (non-Javadoc)
@see com.querydsl.core.types.dsl.SimpleExpression#eq(com.querydsl.core.types.Expression)
*/
@Override
public BooleanExpression eq(Expression<? super T> right) {
return Expressions.booleanOperation(SpatialOps.EQUALS, mixin, right);
}
| 3.26 |
querydsl_GeometryExpression_overlaps_rdh
|
/**
* Returns 1 (TRUE) if this geometric object “spatially overlaps” anotherGeometry.
*
* @param geometry
* other geometry
* @return true, if overlaps
*/
public BooleanExpression overlaps(Expression<? extends Geometry> geometry) {
return Expressions.booleanOperation(SpatialOps.OVERLAPS, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_union_rdh
|
/**
* Returns a geometric object that represents the Point set
* union of this geometric object with anotherGeometry.
*
* @param geometry
* other geometry
* @return union of this and the other geometry
*/
public GeometryExpression<Geometry> union(Expression<? extends Geometry> geometry) {
return GeometryExpressions.geometryOperation(SpatialOps.UNION, mixin, geometry);
}
| 3.26 |
querydsl_GeometryExpression_m0_rdh
|
/**
* Returns 1 (TRUE) if this geometric object “spatially contains” anotherGeometry.
*
* @param geometry
* other geometry
* @return true, if contains
*/
public BooleanExpression m0(Geometry geometry) {
return m0(ConstantImpl.create(geometry));
}
| 3.26 |
querydsl_GroupByBuilder_collection_rdh
|
/**
* Get the results as a list
*
* @param expression
* projection
* @return new result transformer
*/
public <V, RES extends Collection<V>> ResultTransformer<RES> collection(Supplier<RES> resultFactory, FactoryExpression<V> expression) {
final FactoryExpression<V> transformation = FactoryExpressionUtils.wrap(expression);
List<Expression<?>> args = transformation.getArgs();
return new GroupByGenericCollection<K, V, RES>(resultFactory, key, args.toArray(new Expression<?>[args.size()])) {
@Override
protected V transform(Group group) {
// XXX Isn't group.toArray() suitable here?
List<Object> args = new ArrayList<Object>(groupExpressions.size() - 1);
for (int i = 1; i < groupExpressions.size(); i++) {
args.add(group.getGroup(groupExpressions.get(i)));
}
return transformation.newInstance(args.toArray());
}
};
}
| 3.26 |
querydsl_GroupByBuilder_list_rdh
|
/**
* Get the results as a list
*
* @param expression
* projection
* @return new result transformer
*/
public <V> ResultTransformer<List<V>> list(FactoryExpression<V> expression) {
final FactoryExpression<V> transformation = FactoryExpressionUtils.wrap(expression);
List<Expression<?>> args = transformation.getArgs();
return new GroupByList<K, V>(key, args.toArray(new Expression<?>[0])) {
@Override
protected V transform(Group group) {
// XXX Isn't group.toArray() suitable here?
List<Object> args = new ArrayList<Object>(groupExpressions.size() - 1);
for (int i = 1; i < groupExpressions.size(); i++) {
args.add(group.getGroup(groupExpressions.get(i)));}
return transformation.newInstance(args.toArray());
}
};}
| 3.26 |
querydsl_GroupByBuilder_as_rdh
|
/**
* Get the results as a map
*
* @param expression
* projection
* @return new result transformer
*/
public <V> ResultTransformer<Map<K, V>> as(FactoryExpression<V> expression) {
final FactoryExpression<?> transformation = FactoryExpressionUtils.wrap(expression);
List<Expression<?>> args = transformation.getArgs();
return new GroupByMap<K, V>(key, args.toArray(new Expression<?>[0])) {
@Override
protected Map<K, V> transform(Map<K, Group> groups) {
Map<K, V> results = new LinkedHashMap<K, V>(((int) (Math.ceil(groups.size() / 0.75))), 0.75F);
for (Map.Entry<K, Group>
entry : groups.entrySet()) {
results.put(entry.getKey(), transform(entry.getValue()));
}
return results;
}
@SuppressWarnings("unchecked")protected V transform(Group group) {// XXX Isn't group.toArray() suitable here?
List<Object> v14 = new ArrayList<Object>(groupExpressions.size() - 1);
for (int i = 1; i < groupExpressions.size(); i++) {
v14.add(group.getGroup(groupExpressions.get(i))); }
return ((V) (transformation.newInstance(v14.toArray())));
}
};
}
| 3.26 |
querydsl_GroupByBuilder_iterate_rdh
|
/**
* Get the results as a closeable iterator
*
* @param expression
* projection
* @return new result transformer
*/
public <V> ResultTransformer<CloseableIterator<V>> iterate(FactoryExpression<V> expression) {
final FactoryExpression<V> transformation = FactoryExpressionUtils.wrap(expression);
List<Expression<?>> args
= transformation.getArgs();
return new GroupByIterate<K, V>(key, args.toArray(new Expression<?>[0])) {
@Override
protected V transform(Group group) {
// XXX Isn't group.toArray() suitable here?
List<Object> args = new ArrayList<Object>(groupExpressions.size() - 1);
for (int i = 1; i < groupExpressions.size(); i++) {
args.add(group.getGroup(groupExpressions.get(i)));
}
return transformation.newInstance(args.toArray());
}
};
}
| 3.26 |
querydsl_StringExpression_append_rdh
|
/**
* Create a {@code concat(this, str)} expression
*
* <p>Get the concatenation of this and str</p>
*
* @param str
* string to append
* @return this + str
*/
public StringExpression append(Expression<String> str) {
return Expressions.stringOperation(Ops.CONCAT, mixin, str);
}
/**
* Create a {@code concat(this, str)}
| 3.26 |
querydsl_StringExpression_min_rdh
|
/**
* Create a {@code min(this)} expression
*
* <p>Get the minimum value of this expression (aggregation)</p>
*
* @return min(this)
*/
@Override
public StringExpression min() {
if (min == null) {
min = Expressions.stringOperation(AggOps.MIN_AGG, mixin);
}
return min;
}
| 3.26 |
querydsl_StringExpression_equalsIgnoreCase_rdh
|
/**
* Create a {@code this.equalsIgnoreCase(str)} expression
*
* <p>Compares this {@code StringExpression} to another {@code StringExpression}, ignoring case
* considerations.</p>
*
* @param str
* string
* @return this.equalsIgnoreCase(str)
* @see java.lang.String#equalsIgnoreCase(String)
*/
public BooleanExpression equalsIgnoreCase(String str) {
return equalsIgnoreCase(ConstantImpl.create(str));
}
| 3.26 |
querydsl_StringExpression_max_rdh
|
/**
* Create a {@code max(this)} expression
*
* <p>Get the maximum value of this expression (aggregation)</p>
*
* @return max(this)
*/
public StringExpression max() {
if (max == null) {
max = Expressions.stringOperation(AggOps.MAX_AGG, mixin);
}
return max;
}
| 3.26 |
querydsl_StringExpression_indexOf_rdh
|
/**
* Create a {@code this.indexOf(str)} expression
*
* <p>Get the index of the given substring in this String, starting from the given index</p>
*
* @param str
* string
* @param i
* zero based index
* @return this.indexOf(str)
*/
public NumberExpression<Integer> indexOf(Expression<String> str, int i) {
return Expressions.numberOperation(Integer.class, Ops.INDEX_OF_2ARGS, mixin, str, ConstantImpl.create(i));
}
| 3.26 |
querydsl_StringExpression_toLowerCase_rdh
|
/**
* Create a {@code this.toLowerCase()} expression
*
* <p>Get the lower case form</p>
*
* @return this.toLowerCase()
* @see java.lang.String#toLowerCase()
*/
public StringExpression toLowerCase() {
return lower();
}
| 3.26 |
querydsl_StringExpression_m1_rdh
|
/**
* Create a {@code concat(this, str)} expression
*
* <p>Get the concatenation of this and str</p>
*
* @param str
* string to append
* @return this + str
*/
public StringExpression m1(String str) {
return append(str);
}
| 3.26 |
querydsl_StringExpression_endsWithIgnoreCase_rdh
|
/**
* Create a {@code this.endsWithIgnoreCase(str)} expression
*
* <p>Returns true if this ends with str, compares case insensitively</p>
*
* @param str
* string
* @return this.endsWithIgnoreCase(str)
*/
public BooleanExpression endsWithIgnoreCase(String str) {
return endsWithIgnoreCase(ConstantImpl.create(str));}
| 3.26 |
querydsl_StringExpression_upper_rdh
|
/**
* Create a {@code this.toUpperCase()} expression
*
* <p>Get the upper case form</p>
*
* @return this.toUpperCase()
* @see java.lang.String#toUpperCase()
*/
public StringExpression upper() {
if (upper == null) {
upper = Expressions.stringOperation(Ops.UPPER, mixin);
}
return upper;
}
| 3.26 |
querydsl_StringExpression_startsWith_rdh
|
/**
* Create a {@code this.startsWith(str)} expression
*
* <p>Return true if this starts with str</p>
*
* @param str
* string
* @return this.startsWith(str)
* @see java.lang.String#startsWith(String)
*/
public BooleanExpression startsWith(String str) {
return startsWith(ConstantImpl.create(str));
}
| 3.26 |
querydsl_StringExpression_length_rdh
|
/**
* Create a {@code this.length()} expression
*
* <p>Return the length of this String</p>
*
* @return this.length()
* @see java.lang.String#length()
*/
public NumberExpression<Integer> length() {
if (length == null) {
length = Expressions.numberOperation(Integer.class, Ops.STRING_LENGTH, mixin);
}
return length;
}
| 3.26 |
querydsl_StringExpression_contains_rdh
|
/**
* Create a {@code this.contains(str)} expression
*
* <p>Returns true if the given String is contained</p>
*
* @param str
* string
* @return this.contains(str)
* @see java.lang.String#contains(CharSequence)
*/public BooleanExpression contains(String str) {
return contains(ConstantImpl.create(str));
}
| 3.26 |
querydsl_StringExpression_m0_rdh
|
/**
* Create a {@code this.charAt(i)} expression
*
* <p>Get the character at the given index</p>
*
* @param i
* zero based index
* @return this.charAt(i)
* @see java.lang.String#charAt(int)
*/
public SimpleExpression<Character> m0(Expression<Integer>
i) {return Expressions.comparableOperation(Character.class, Ops.CHAR_AT, mixin, i);
}
| 3.26 |
querydsl_StringExpression_notEqualsIgnoreCase_rdh
|
/**
* Create a {@code !this.equalsIgnoreCase(str)} expression
*
* <p>Compares this {@code StringExpression} to another {@code StringExpression}, ignoring case
* considerations.</p>
*
* @param str
* string
* @return !this.equalsIgnoreCase(str)
* @see java.lang.String#equalsIgnoreCase(String)
*/
public BooleanExpression notEqualsIgnoreCase(String str) {
return equalsIgnoreCase(str).not();
}
| 3.26 |
querydsl_StringExpression_m4_rdh
|
/**
* Create a {@code coalesce(this, arg)} expression
*
* @param arg
* additional argument
* @return coalesce
*/
@Override
public StringExpression m4(String arg) {
Coalesce<String> coalesce = new Coalesce<String>(getType(), mixin);
coalesce.add(arg);
return coalesce.asString();
}
| 3.26 |
querydsl_StringExpression_like_rdh
|
/**
* Create a {@code this like str} expression
*
* @param str
* string
* @return this like str
*/
public BooleanExpression like(Expression<String> str, char escape) {
return Expressions.booleanOperation(Ops.LIKE_ESCAPE, mixin, str, ConstantImpl.create(escape));
}
| 3.26 |
querydsl_StringExpression_toUpperCase_rdh
|
/**
* Create a {@code this.toUpperCase()} expression
*
* <p>Get the upper case form</p>
*
* @return this.toUpperCase()
* @see java.lang.String#toUpperCase()
*/
public StringExpression toUpperCase() {
return upper();
}
| 3.26 |
querydsl_StringExpression_prepend_rdh
|
/**
* Create a {@code concat(str, this)} expression
*
* <p>Prepend the given String and return the result</p>
*
* @param str
* string
* @return str + this
*/
public StringExpression prepend(String str) {
return prepend(ConstantImpl.create(str));
}
| 3.26 |
querydsl_StringExpression_charAt_rdh
|
/**
* Create a {@code this.charAt(i)} expression
*
* <p>Get the character at the given index</p>
*
* @param i
* zero based index
* @return this.charAt(i)
* @see java.lang.String#charAt(int)
*/
public SimpleExpression<Character> charAt(int i) {
return charAt(ConstantImpl.create(i));
}
| 3.26 |
querydsl_StringExpression_matches_rdh
|
/**
* Create a {@code this.matches(regex)} expression
*
* <p>Return true if this String matches the given regular expression</p>
*
* <p>Some implementations such as Querydsl JPA will try to convert a regex expression into like
* form and will throw an Exception when this fails</p>
*
* @param regex
* regular expression
* @return this.matches(regex)
* @see java.lang.String#matches(String)
*/
public BooleanExpression matches(String regex) {
return matches(ConstantImpl.create(regex));
}
| 3.26 |
querydsl_StringExpression_m2_rdh
|
/**
* Create a {@code !this.isEmpty()} expression
*
* <p>Return true if this String is not empty</p>
*
* @return !this.isEmpty()
* @see java.lang.String#isEmpty()
*/
public BooleanExpression m2() {
return isEmpty().not();
}
| 3.26 |
querydsl_StringExpression_isEmpty_rdh
|
/**
* Create a {@code this.isEmpty()} expression
*
* <p>Return true if this String is empty</p>
*
* @return this.isEmpty()
* @see java.lang.String#isEmpty()
*/
public BooleanExpression isEmpty() {
if (f0 == null) {
f0 = Expressions.booleanOperation(Ops.STRING_IS_EMPTY, mixin);
}
return f0;}
| 3.26 |
querydsl_StringExpression_nullif_rdh
|
/**
* Create a {@code nullif(this, other)} expression
*
* @param other
* @return nullif(this, other)
*/
@Override
public StringExpression nullif(String other) {
return nullif(ConstantImpl.create(other));
}
| 3.26 |
querydsl_StringExpression_likeIgnoreCase_rdh
|
/**
* Create a {@code this like str} expression ignoring case
*
* @param str
* string
* @param escape
* escape character
* @return this like string
*/
public BooleanExpression likeIgnoreCase(Expression<String> str, char escape) {
return Expressions.booleanOperation(Ops.LIKE_ESCAPE_IC, mixin, str, ConstantImpl.create(escape));
}
| 3.26 |
querydsl_StringExpression_substring_rdh
|
/**
* Create a {@code this.substring(beginIndex, endIndex)} expression
*
* @param beginIndex
* inclusive start index
* @param endIndex
* exclusive end index
* @return this.substring(beginIndex, endIndex)
* @see java.lang.String#substring(int, int)
*/
public StringExpression substring(Expression<Integer> beginIndex, Expression<Integer> endIndex) {
return Expressions.stringOperation(Ops.SUBSTR_2ARGS, mixin,
beginIndex, endIndex);
}
| 3.26 |
querydsl_StringExpression_containsIgnoreCase_rdh
|
/**
* Create a {@code this.containsIgnoreCase(str)} expression
*
* <p>Returns true if the given String is contained, compare case insensitively</p>
*
* @param str
* string
* @return this.containsIgnoreCase(str) expression
*/
public BooleanExpression containsIgnoreCase(Expression<String> str) {
return Expressions.booleanOperation(Ops.STRING_CONTAINS_IC, mixin, str);
}
/**
* Create a {@code this.containsIgnoreCase(str)}
| 3.26 |
querydsl_StringExpression_trim_rdh
|
/**
* Create a {@code this.trim()} expression
*
* <p>Create a copy of the string, with leading and trailing whitespace
* omitted.</p>
*
* @return this.trim()
* @see java.lang.String#trim()
*/
public StringExpression trim() {
if (trim == null) {
trim = Expressions.stringOperation(Ops.TRIM, mixin);
}
return trim;
}
| 3.26 |
querydsl_StringExpression_concat_rdh
|
/**
* Create a {@code concat(this, str)} expression
*
* <p>Get the concatenation of this and str</p>
*
* @param str
* string to append
* @return this + str
*/
public StringExpression concat(Expression<String> str) {
return append(str);
}
| 3.26 |
querydsl_StringExpression_startsWithIgnoreCase_rdh
|
/**
* Create a {@code this.startsWithIgnoreCase(str)} expression
*
* @param str
* string
* @return this.startsWithIgnoreCase(str)
*/
public BooleanExpression startsWithIgnoreCase(String str) { return startsWithIgnoreCase(ConstantImpl.create(str));
}
| 3.26 |
querydsl_StringExpression_locate_rdh
|
/**
* Create a {@code locate(str, this, start)} expression
*
* <p>Get the position of the given String in this String, the first position is 1</p>
*
* @param str
* string
* @param start
* start
* @return locate(str, this, start)
*/
public NumberExpression<Integer> locate(String str, Expression<Integer> start) {
return Expressions.numberOperation(Integer.class, StringOps.LOCATE2, ConstantImpl.create(str), mixin, start);
}
/**
* Create a {@code this.toLowerCase()}
| 3.26 |
querydsl_StringExpression_m3_rdh
|
/**
* Create a {@code this.substring(beginIndex, endIndex)} expression
*
* @param beginIndex
* inclusive start index
* @param endIndex
* exclusive end index
* @return this.substring(beginIndex, endIndex)
* @see java.lang.String#substring(int, int)
*/
public StringExpression m3(int beginIndex, Expression<Integer> endIndex) {
return Expressions.stringOperation(Ops.SUBSTR_2ARGS, mixin, ConstantImpl.create(beginIndex), endIndex);
}
| 3.26 |
querydsl_StringExpression_notLike_rdh
|
/**
* Create a {@code this not like str} expression
*
* @param str
* string
* @return this not like str
*/
public BooleanExpression notLike(Expression<String> str, char escape) {
return like(str, escape).not();
}
| 3.26 |
querydsl_StringExpression_coalesce_rdh
|
/**
* Create a {@code coalesce(this, args...)} expression
*
* @param args
* additional arguments
* @return coalesce
*/
@Override
public StringExpression coalesce(String... args) {
Coalesce<String> coalesce = new Coalesce<String>(getType(), mixin);
for (String arg : args) {
coalesce.add(arg);
}
return coalesce.asString();
}
| 3.26 |
querydsl_StringExpression_endsWith_rdh
|
/**
* Create a {@code this.endsWith(str)} expression
*
* <p>Returns true if this ends with str</p>
*
* @param str
* string
* @return this.endsWith(str)
* @see java.lang.String#endsWith(String)
*/
public BooleanExpression endsWith(String str) {
return endsWith(ConstantImpl.create(str));
}
| 3.26 |
querydsl_JTSMultiCurveExpression_isClosed_rdh
|
/**
* Returns 1 (TRUE) if this MultiCurve is closed [StartPoint ( ) = EndPoint ( ) for each
* Curve in this MultiCurve].
*
* @return closed
*/
public BooleanExpression isClosed() {
if (f0 == null) {
f0 = Expressions.booleanOperation(SpatialOps.IS_CLOSED, mixin);
}
return f0;
}
| 3.26 |
querydsl_JTSMultiCurveExpression_length_rdh
|
/**
* The Length of this MultiCurve which is equal to the sum of the lengths of the element
* Curves.
*
* @return length
*/
public NumberExpression<Double> length() {
if (length == null) {
length = Expressions.numberOperation(Double.class, SpatialOps.LENGTH, mixin);
}
return length;
}
| 3.26 |
querydsl_JPQLTemplates_isEnumInPathSupported_rdh
|
// kept for backwards compatibility
@Deprecated
public boolean isEnumInPathSupported() {
return true;
}
| 3.26 |
querydsl_JPAListAccessVisitor_shorten_rdh
|
/**
* Shorten the parent path to a length of max 2 elements
*/
private Path<?> shorten(Path<?> path, boolean outer) {
if (aliases.containsKey(path)) {
return aliases.get(path);
} else if (path.getMetadata().isRoot()) {
return path;
} else if (path.getMetadata().getParent().getMetadata().isRoot() && outer) {
return path;
} else {
Class<?> type = JPAQueryMixin.getElementTypeOrType(path);
Path<?> parent = shorten(path.getMetadata().getParent(), false);
Path oldPath = ExpressionUtils.path(path.getType(), new PathMetadata(parent, path.getMetadata().getElement(), path.getMetadata().getPathType()));
if (oldPath.getMetadata().getParent().getMetadata().isRoot() && outer) {
return oldPath;
} else {
Path newPath = ExpressionUtils.path(type, ExpressionUtils.createRootVariable(oldPath));
aliases.put(path, newPath);
metadata.addJoin(JoinType.LEFTJOIN, ExpressionUtils.as(oldPath, newPath));
return newPath;
}
}
}
| 3.26 |
querydsl_FunctionalHelpers_wrap_rdh
|
/**
* Wrap a Querydsl expression into a Guava function
*
* @param projection
* projection to wrap
* @return Guava function
*/
public static <F, T> Function<F, T> wrap(Expression<T>
projection) {
Path<?> path = projection.accept(PathExtractor.DEFAULT, null);
if (path != null) {
final Evaluator<T> ev = createEvaluator(path.getRoot(), projection);
return ev::evaluate;
} else {
throw new IllegalArgumentException("No path in " + projection);
}
}
| 3.26 |
querydsl_DefaultEntitySerializer_wrap_rdh
|
// TODO move this to codegen
private Type wrap(Type type) {
if (type.equals(Types.BOOLEAN_P)) {
return Types.BOOLEAN;
} else if (type.equals(Types.BYTE_P))
{
return Types.BYTE;
} else if (type.equals(Types.CHAR)) {
return Types.CHARACTER;
} else if
(type.equals(Types.DOUBLE_P)) {
return Types.DOUBLE;
} else if (type.equals(Types.FLOAT_P)) {
return Types.FLOAT;
} else if (type.equals(Types.INT)) {
return Types.INTEGER;
} else if (type.equals(Types.LONG_P)) {
return Types.LONG;
} else if (type.equals(Types.SHORT_P)) {
return Types.SHORT;
} else {
return type;
}
}
| 3.26 |
querydsl_AbstractSQLDeleteClause_addFlag_rdh
|
/**
* Add the given Expression at the given position as a query flag
*
* @param position
* position
* @param flag
* query flag
* @return the current object
*/
public C addFlag(Position position, Expression<?> flag) {
metadata.addFlag(new QueryFlag(position, flag));
return ((C) (this));
}
| 3.26 |
querydsl_AbstractSQLDeleteClause_addBatch_rdh
|
/**
* Add current state of bindings as a batch item
*
* @return the current object
*/
public C addBatch() {
batches.add(metadata);
metadata = new DefaultQueryMetadata();
metadata.addJoin(JoinType.DEFAULT, entity);
metadata.setValidatingVisitor(validatingVisitor);
return ((C) (this));
}
| 3.26 |
querydsl_AbstractOracleQuery_orderSiblingsBy_rdh
|
/**
* ORDER SIBLINGS BY preserves any ordering specified in the hierarchical query clause and then
* applies the order_by_clause to the siblings of the hierarchy.
*
* @param path
* path
* @return the current object
*/
public C
orderSiblingsBy(Expression<?> path) {
return addFlag(Position.BEFORE_ORDER, ORDER_SIBLINGS_BY, path);
}
| 3.26 |
querydsl_AbstractOracleQuery_connectBy_rdh
|
/**
* CONNECT BY specifies the relationship between parent rows and child rows of the hierarchy.
*
* @param cond
* condition
* @return the current object
*/
public C connectBy(Predicate cond) {
return addFlag(Position.BEFORE_ORDER, CONNECT_BY, cond);
}
| 3.26 |
querydsl_AbstractOracleQuery_connectByNocyclePrior_rdh
|
/**
* CONNECT BY specifies the relationship between parent rows and child rows of the hierarchy.
*
* @param cond
* condition
* @return the current object
*/
public C connectByNocyclePrior(Predicate cond) {
return addFlag(Position.BEFORE_ORDER, CONNECT_BY_NOCYCLE_PRIOR, cond);
}
| 3.26 |
querydsl_AbstractOracleQuery_startWith_rdh
|
/**
* START WITH specifies the root row(s) of the hierarchy.
*
* @param cond
* condition
* @return the current object
*/
public <A> C startWith(Predicate cond) {return addFlag(Position.BEFORE_ORDER, START_WITH, cond);
}
| 3.26 |
querydsl_AbstractOracleQuery_connectByPrior_rdh
|
/**
* CONNECT BY specifies the relationship between parent rows and child rows of the hierarchy.
*
* @param cond
* condition
* @return the current object
*/
public C connectByPrior(Predicate cond) {
return addFlag(Position.BEFORE_ORDER, CONNECT_BY_PRIOR, cond);
}
| 3.26 |
querydsl_QueryBase_distinct_rdh
|
/**
* Set the Query to return distinct results
*
* @return the current object
*/
public Q distinct() {
return queryMixin.distinct();
}
| 3.26 |
querydsl_QueryBase_m0_rdh
|
/**
* Set the given parameter to the given value
*
* @param <P>
* @param param
* param
* @param value
* binding
* @return the current object
*/public <P> Q m0(ParamExpression<P> param, P value) {
return queryMixin.set(param, value);
}
| 3.26 |
querydsl_QueryBase_orderBy_rdh
|
/**
* Add order expressions
*
* @param o
* order
* @return the current object
*/
public Q orderBy(OrderSpecifier<?>... o) {
return queryMixin.orderBy(o);
}
| 3.26 |
querydsl_QueryBase_having_rdh
|
/**
* Add filters for aggregation
*
* @param o
* having conditions
* @return the current object
*/
public Q having(Predicate... o) {
return queryMixin.having(o);
}
| 3.26 |
querydsl_QueryBase_offset_rdh
|
/**
* Defines the offset for the query results
*
* @param offset
* row offset
* @return the current object
*/
public Q offset(long offset) {
return queryMixin.offset(offset);
}
| 3.26 |
querydsl_QueryBase_groupBy_rdh
|
/**
* Add grouping/aggregation expressions
*
* @param o
* group by expressions
* @return the current object
*/
public Q groupBy(Expression<?>... o) {
return queryMixin.groupBy(o);
}
| 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.