name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
querydsl_AbstractCollQuery_leftJoin_rdh | /**
* Define a left join from the Map typed path to the alias
*
* @param <P>
* type of expression
* @param target
* target of the join
* @param alias
* alias for the joint target
* @return current object
*/
public <P> Q leftJoin(MapExpression<?, P> target, Path<P> alias)
{
m1().addJoin(JoinType.LEFT... | 3.26 |
querydsl_ColumnMetadata_getDigits_rdh | /**
* the number of fractional digits
*
* @return digits
*/ public int getDigits() {
return decimalDigits;
} | 3.26 |
querydsl_ColumnMetadata_m0_rdh | /**
* Creates default column meta data with the given column name, but without
* any type or constraint information. Use the fluent builder methods to
* further configure it.
*
* @throws NullPointerException
* if the name is null
*/
public static ColumnMetadata m0(String name) {
return
new ColumnMetad... | 3.26 |
querydsl_ColumnMetadata_getColumnMetadata_rdh | /**
* Returns this path's column metadata if present. Otherwise returns default
* metadata where the column name is equal to the path's name.
*/
public static ColumnMetadata getColumnMetadata(Path<?> path) {
Path<?> v0 = path.getMetadata().getParent();
if (v0 instanceof EntityPath) {
Object v1 = ((E... | 3.26 |
querydsl_AbstractGeometryCollectionExpression_numGeometries_rdh | /**
* Returns the number of geometries in this GeometryCollection.
*
* @return number of geometries
*/
public NumberExpression<Integer> numGeometries() {
if (numGeometries == null) {
numGeometries =
Expressions.numberOperation(Integer.class, SpatialOps.NUM_GEOMETRIES, mixin);
}
... | 3.26 |
querydsl_AbstractGeometryCollectionExpression_geometryN_rdh | /**
* Returns the Nth geometry in this GeometryCollection.
*
* @param n
* one based index
* @return matching geometry
*/
public GeometryExpression<Geometry> geometryN(Integer n) {
return GeometryExpressions.geometryOperation(SpatialOps.GEOMETRYN, mixin, ConstantImpl.create(n));
} | 3.26 |
querydsl_MySQLQueryFactory_insertOnDuplicateKeyUpdate_rdh | /**
* Create a INSERT ... ON DUPLICATE KEY UPDATE clause
*
* @param entity
* table to insert to
* @param clauses
* clauses
* @return insert clause
*/
public SQLInsertClause insertOnDuplicateKeyUpdate(RelationalPath<?> entity, Expression<?>... clauses) {
SQLInsertClause insert = insert(entity);
StringBuild... | 3.26 |
querydsl_MySQLQueryFactory_insertIgnore_rdh | /**
* Create a INSERT IGNORE INTO clause
*
* @param entity
* table to insert to
* @return insert clause
*/
public SQLInsertClause insertIgnore(RelationalPath<?> entity) {
SQLInsertClause insert = insert(entity);
insert.addFlag(Position.START_OVERRIDE, "insert ignore into ");
retu... | 3.26 |
querydsl_JTSGeometryExpression_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_JTSGeometryExpression_boundary_rdh | /**
* Returns the closure of the combinatorial boundary of this geometric object
*
* @return boundary
*/
public JTSGeometryExpression<Geometry> boundary() {
if (boundary == null) {
boundary = JTSGeometryExpressions.geometryOperation(SpatialOps.BOUNDARY, mixin);
}
return boundary;
} | 3.26 |
querydsl_JTSGeometryExpression_overlaps_rdh | /**
* Returns 1 (TRUE) if this geometric object “spatially overlaps” anotherGeometry.
*
* @param geometry
* other geometry
* @return true, if overlaps
*/
public BooleanExpression overlaps(Geometry geometry) {
return overlaps(ConstantImpl.create(geometry));
} | 3.26 |
querydsl_JTSGeometryExpression_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_JTSGeometryExpression_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 JTSGeometryExpression<Geometry> union(Geometry geometry) {
return union(ConstantImpl.create(ge... | 3.26 |
querydsl_JTSGeometryExpression_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_JTSGeometryExpression_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 posit... | 3.26 |
querydsl_JTSGeometryExpression_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
*/
public JTSGeometryExpression<Geometry> symDifference(Expression<? extends Geometry> geometry) {
return ... | 3.26 |
querydsl_JTSGeometryExpression_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 JTSGeometryExpression<Geometry> intersection(Expression<? extends Geometry> geometry)... | 3.26 |
querydsl_JTSGeometryExpression_contains_rdh | /**
* Returns 1 (TRUE) if this geometric object “spatially contains” anotherGeometry.
*
* @param geometry
* other geometry
* @return true, if contains
*/public BooleanExpression contains(Expression<? extends Geometry>
geometry) {
return Expressions.booleanOperation(SpatialOps.CONTAINS, mixin, geometry);
} | 3.26 |
querydsl_JTSGeometryExpression_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 empt... | 3.26 |
querydsl_JTSGeometryExpression_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_JTSGeometryExpression_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... | 3.26 |
querydsl_JTSGeometryExpression_isSimple_rdh | /**
* Returns 1 (TRUE) if this geometric object has no anomalous geometric points, such
* as self intersection or self tangency. The description of each instantiable geometric class
* will include the specific conditions that cause an instance of that class to be classified as not simple.
*
* @return simple
*/
pu... | 3.26 |
querydsl_JTSGeometryExpression_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 erro... | 3.26 |
querydsl_JTSGeometryExpression_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, geome... | 3.26 |
querydsl_JTSGeometryExpression_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... | 3.26 |
querydsl_JTSGeometryExpression_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 ... | 3.26 |
querydsl_JTSGeometryExpression_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)... | 3.26 |
querydsl_JTSGeometryExpression_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 JTSGeometryExpression<Geometry> difference(Expression<? extends Geometry>
geometry) ... | 3.26 |
querydsl_JTSGeometryExpression_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 = Expres... | 3.26 |
querydsl_JTSGeometryExpression_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_JTSGeometryExpression_convexHull_rdh | /**
* Returns a geometric object that represents the convex hull of this geometric object.
* Convex hulls, being dependent on straight lines, can be accurately represented in linear
* interpolations for any geometry restricted to linear interpolations.
*
* @return convex hull
*/
public JTSGeometryExpression<Geome... | 3.26 |
querydsl_JTSGeometryExpression_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, geomet... | 3.26 |
querydsl_TeradataQuery_m0_rdh | /**
* Adds a qualify expression
*
* @param predicate
* qualify expression
* @return the current object
*/
public TeradataQuery<T> m0(Predicate predicate) {
predicate
= ExpressionUtils.predicate(SQLOps.QUALIFY, predicate);
return queryMixin.addFlag(new QueryFlag(Position.BEFORE_ORDER, predicate));} | 3.26 |
querydsl_AbstractMySQLQuery_withRollup_rdh | /**
* The GROUP BY clause permits a WITH ROLLUP modifier that causes extra rows to be added to the
* summary output. These rows represent higher-level (or super-aggregate) summary operations.
* ROLLUP thus enables you to answer questions at multiple levels of analysis with a single query.
* It can be used, for exam... | 3.26 |
querydsl_AbstractMySQLQuery_forceIndex_rdh | /**
* You can use FORCE INDEX, which acts like USE INDEX (index_list) but with the addition that a
* table scan is assumed to be very expensive. In other words, a table scan is used only if there
* is no way to use one of the given indexes to find rows in the table.
*
* @param indexes
* index names
* @return t... | 3.26 |
querydsl_AbstractMySQLQuery_useIndex_rdh | /**
* By specifying USE INDEX (index_list), you can tell MySQL to use only one of the named indexes
* to find rows in the table.
*
* @param indexes
* index names
* @return the current object
*/
public C useIndex(String... indexes) {return addJoinFlag((" use index (" + String.join(", ", indexes)) + ")", Positi... | 3.26 |
querydsl_AbstractMySQLQuery_ignoreIndex_rdh | /**
* The alternative syntax IGNORE INDEX (index_list) can be used to tell MySQL to not use some
* particular index or indexes.
*
* @param indexes
* index names
* @return the current object
*/
public C ignoreIndex(String... indexes) {
return addJoinFlag((" ignore index (" + String.join(", ", indexes)) + ")... | 3.26 |
querydsl_AbstractMySQLQuery_into_rdh | /**
* SELECT ... INTO var_list selects column values and stores them into variables.
*
* @param var
* variable name
* @return the current object
*/
public C into(String var) {
return addFlag(Position.END, "\ninto " + var);
} | 3.26 |
querydsl_AbstractMySQLQuery_intoDumpfile_rdh | /**
* SELECT ... INTO DUMPFILE writes a single row to a file without any formatting.
*
* @param file
* file to write to
* @return the current object
*/
public C intoDumpfile(File file) {
return addFlag(Position.END, ("\ninto dumpfile '" + file.getPath()) + "'");
} | 3.26 |
querydsl_AbstractMySQLQuery_noCache_rdh | /**
* With SQL_NO_CACHE, the server does not use the query cache. It neither checks the query cache
* to see whether the result is already cached, nor does it cache the query result.
*
* @return the current object
*/
public C noCache() {
return addFlag(Position.AFTER_SELECT, SQL_NO_CACHE);
} | 3.26 |
querydsl_AbstractMySQLQuery_straightJoin_rdh | /**
* STRAIGHT_JOIN forces the optimizer to join the tables in the order in which they are listed
* in the FROM clause. You can use this to speed up a query if the optimizer joins the tables
* in nonoptimal order. STRAIGHT_JOIN also can be used in the table_references list.
*
* @return the current object
*/
publi... | 3.26 |
querydsl_AbstractMySQLQuery_highPriority_rdh | /**
* HIGH_PRIORITY gives the SELECT higher priority than a statement that updates a table.
* You should use this only for queries that are very fast and must be done at once.
*
* @return the current object
*/
public C highPriority() {
return addFlag(Position.AFTER_SELECT, HIGH_PRIORITY);} | 3.26 |
querydsl_AbstractSQLUpdateClause_m0_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 m0(Position position, Expression<?> flag) {
metadata.addFlag(new QueryFlag(position, flag));
return ((C) (this));
} | 3.26 |
querydsl_AbstractSQLUpdateClause_addBatch_rdh | /**
* Add the current state of bindings as a batch item
*
* @return the current object
*/
public C addBatch() {
batches.add(new SQLUpdateBatch(metadata, updates));
updates = new LinkedHashMap<>();
metadata = new DefaultQueryMetadata();
metadata.addJoin(JoinType.DEFAULT, entity);
return ((C)... | 3.26 |
querydsl_AbstractSQLUpdateClause_populate_rdh | /**
* Populate the UPDATE clause with the properties of the given bean using the given Mapper.
*
* @param obj
* object to use for population
* @param mapper
* mapper to use
* @return the current object
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public <T> C populate(T obj, Mapper<T> mapper) {Collec... | 3.26 |
querydsl_AbstractSQLUpdateClause_addFlag_rdh | /**
* Add the given String literal at the given position as a query flag
*
* @param position
* position
* @param flag
* query flag
* @return the current object
*/
public C addFlag(Position position, String flag) {
metadata.addFlag(new QueryFlag(position, flag));
return ((C) (this));
} | 3.26 |
querydsl_PropertyHandling_getConfig_rdh | /**
* JPA compatibility
*/ JPA() {
@Override
public Config
getConfig(Class<?> type) {
boolean fields = false;
boolean methods = false;
for (Field field : type.getDeclaredFields()) {
fields |= hasAnnotations(field, "javax.persistence.");
fields |= hasAnnotati... | 3.26 |
querydsl_GenericExporter_setUseFieldTypes_rdh | /**
* Set whether field types should be used instead of getter return types (default false)
*
* @param b
*/
public void setUseFieldTypes(boolean b) {
f0 = b;
} | 3.26 |
querydsl_GenericExporter_setEmbeddedAnnotation_rdh | /**
* Set the embedded annotation
*
* @param embeddedAnnotation
* embedded annotation
*/
public void setEmbeddedAnnotation(Class<? extends Annotation> embeddedAnnotation) {
this.embeddedAnnotation = embeddedAnnotation;
} | 3.26 |
querydsl_GenericExporter_setHandleMethods_rdh | /**
* Set whether methods are handled (default true)
*
* @param b
* @deprecated Use {@link #setPropertyHandling(PropertyHandling)} instead
*/
@Deprecated
public void setHandleMethods(boolean b) {
handleMethods = b;
setPropertyHandling();
} | 3.26 |
querydsl_GenericExporter_setKeywords_rdh | /**
* Set the keywords to be used
*
* @param keywords
*/
public void setKeywords(Collection<String> keywords) {
codegenModule.bind(CodegenModule.KEYWORDS, keywords);
} | 3.26 |
querydsl_GenericExporter_getGeneratedFiles_rdh | /**
* Return the set of generated files
*
* @return a set of generated files
*/
public Set<File> getGeneratedFiles() {
return generatedFiles;
} | 3.26 |
querydsl_GenericExporter_setTargetFolder_rdh | /**
* Set the target folder for generated sources
*
* @param targetFolder
*/
public void setTargetFolder(File targetFolder) {
this.targetFolder = targetFolder;
} | 3.26 |
querydsl_GenericExporter_addAnnotationHelper_rdh | /**
* Add a annotation helper object to process custom annotations
*
* @param annotationHelper
*/
public void addAnnotationHelper(AnnotationHelper annotationHelper) {
annotationHelpers.add(annotationHelper);
} | 3.26 |
querydsl_GenericExporter_setGeneratedAnnotationClass_rdh | /**
* Set the Generated annotation class. Will default to java {@code @Generated}
*
* @param generatedAnnotationClass
* the fully qualified class name of the <em>Single-Element Annotation</em> (with {@code String} element) to be used on
* the generated sources, or {@code null} (defaulting to {@code javax.annot... | 3.26 |
querydsl_GenericExporter_setPackageSuffix_rdh | /**
* Set the package suffix
*
* @param suffix
*/
public void setPackageSuffix(String suffix) {
codegenModule.bind(CodegenModule.PACKAGE_SUFFIX, suffix);
} | 3.26 |
querydsl_GenericExporter_addStopClass_rdh | /**
* Add a stop class to be used (default Object.class and Enum.class)
*
* @param cl
*/
public void addStopClass(Class<?> cl)
{
stopClasses.add(cl);
} | 3.26 |
querydsl_GenericExporter_setNamePrefix_rdh | /**
* Set the name prefix
*
* @param prefix
*/
public void setNamePrefix(String prefix) {
codegenModule.bind(CodegenModule.PREFIX, prefix);} | 3.26 |
querydsl_GenericExporter_setSerializerConfig_rdh | /**
* Set the serializer configuration to use
*
* @param serializerConfig
*/
public void setSerializerConfig(SerializerConfig serializerConfig) {
this.serializerConfig = serializerConfig;} | 3.26 |
querydsl_GenericExporter_setSkipAnnotation_rdh | /**
* Set the skip annotation
*
* @param skipAnnotation
* skip annotation
*/
public void setSkipAnnotation(Class<? extends Annotation> skipAnnotation) {
this.skipAnnotation = skipAnnotation;
} | 3.26 |
querydsl_GenericExporter_setSupertypeAnnotation_rdh | /**
* Set the supertype annotation
*
* @param supertypeAnnotation
* supertype annotation
*/
public void setSupertypeAnnotation(Class<? extends Annotation> supertypeAnnotation) {
this.supertypeAnnotation = supertypeAnnotation;
} | 3.26 |
querydsl_GenericExporter_setTypeMappingsClass_rdh | /**
* Set the typemappings class to be used
*
* @param typeMappingsClass
*/public void setTypeMappingsClass(Class<? extends TypeMappings> typeMappingsClass) {
codegenModule.bind(TypeMappings.class, typeMappingsClass);
} | 3.26 |
querydsl_GenericExporter_setEntityAnnotation_rdh | /**
* Set the entity annotation
*
* @param entityAnnotation
* entity annotation
*/
public void setEntityAnnotation(Class<? extends Annotation> entityAnnotation) {
this.entityAnnotation = entityAnnotation;
} | 3.26 |
querydsl_GenericExporter_setHandleFields_rdh | /**
* Set whether fields are handled (default true)
*
* @param b
* @deprecated Use {@link #setPropertyHandling(PropertyHandling)} instead
*/
@Deprecated
public void setHandleFields(boolean b) {
handleFields = b;
setPropertyHandling();
} | 3.26 |
querydsl_GenericExporter_setNameSuffix_rdh | /**
* Set the name suffix
*
* @param suffix
*/
public void setNameSuffix(String suffix) {
codegenModule.bind(CodegenModule.SUFFIX, suffix);
} | 3.26 |
querydsl_GenericExporter_setSerializerClass_rdh | /**
* Set the serializer class to be used
*
* @param serializerClass
*/
public void setSerializerClass(Class<? extends Serializer> serializerClass) {
codegenModule.bind(serializerClass);
this.serializerClass = serializerClass;
} | 3.26 |
querydsl_GenericExporter_export_rdh | /**
* Export the given classes
*
* @param classes
* classes to be scanned
*/
public void export(Class<?>... classes) {
for (Class<?> cl : classes) {
handleClass(cl);
}
innerExport();
} | 3.26 |
querydsl_GenericExporter_setPropertyHandling_rdh | /**
* Set the property handling mode
*
* @param propertyHandling
*/
public void setPropertyHandling(PropertyHandling propertyHandling) { this.propertyHandling = propertyHandling;
} | 3.26 |
querydsl_GenericExporter_setStrictMode_rdh | /**
* Set whether annotationless superclasses are handled or not (default: true)
*
* @param s
*/
public void setStrictMode(boolean s) {
strictMode = s;
} | 3.26 |
querydsl_GenericExporter_setCreateScalaSources_rdh | /**
* Set whether Scala sources are generated
*
* @param createScalaSources
*/
public void setCreateScalaSources(boolean createScalaSources) {
this.createScalaSources = createScalaSources;
} | 3.26 |
querydsl_GenericExporter_setEmbeddableAnnotation_rdh | /**
* Set the embeddable annotation
*
* @param embeddableAnnotation
* embeddable annotation
*/
public void setEmbeddableAnnotation(Class<? extends Annotation> embeddableAnnotation) {
this.embeddableAnnotation = embeddableAnnotation;
} | 3.26 |
querydsl_QueryModifiers_subList_rdh | /**
* Get a sublist based on the restriction of limit and offset
*
* @param <T>
* @param list
* list to be handled
* @return sublist with limit and offset applied
*/
public <T> List<T> subList(List<T> list) {
if (!list.isEmpty()) {
int from = (offset != null) ? toInt(offset) : 0;
int to = (limit != null) ? ... | 3.26 |
querydsl_JPAExpressions_treat_rdh | /**
* Create a JPA 2.1 treated path.
*
* @param path
* The path to apply the treat operation on
* @param subtype
* subtype class
* @param <U>
* the subtype class
* @param <T>
* the expression type
* @return subtype instance with the same identity
*/
public static <U extends BeanPath<? extends T>, ... | 3.26 |
querydsl_JPAExpressions_selectZero_rdh | /**
* Create a new detached JPQLQuery instance with the projection zero
*
* @return select(0)
*/public static JPQLQuery<Integer> selectZero() {
return select(Expressions.ZERO);} | 3.26 |
querydsl_JPAExpressions_selectFrom_rdh | /**
* Create a new detached JPQLQuery instance with the given projection
*
* @param expr
* projection and source
* @param <T>
* @return select(expr).from(expr)
*/
public static <T> JPQLQuery<T> selectFrom(EntityPath<T> expr) {
return
select(expr).from(expr);
} | 3.26 |
querydsl_JPAExpressions_type_rdh | /**
* Create a type(path) expression
*
* @param path
* entity
* @return type(path)
*/
public static StringExpression type(EntityPath<?> path) {
return Expressions.stringOperation(JPQLOps.TYPE, path);
} | 3.26 |
querydsl_JPAExpressions_selectDistinct_rdh | /**
* Create a new detached JPQLQuery instance with the given projection
*
* @param exprs
* projection
* @return select(distinct expr)
*/
public static JPQLQuery<Tuple> selectDistinct(Expression<?>... exprs) {
return new JPASubQuery<Void>().select(exprs).distinct();
} | 3.26 |
querydsl_JPAExpressions_select_rdh | /**
* Create a new detached JPQLQuery instance with the given projection
*
* @param exprs
* projection
* @return select(exprs)
*/
public static JPQLQuery<Tuple> select(Expression<?>... exprs) {
return new JPASubQuery<Void>().select(exprs);
} | 3.26 |
querydsl_JPAExpressions_min_rdh | /**
* Create a min(col) expression
*
* @param left
* collection
* @return min(col)
*/
public static <A extends Comparable<? super A>> ComparableExpression<A> min(CollectionExpression<?, A> left) {
return Expressions.comparableOperation(((Class) (left.getParameter(0))), QuantOps.MIN_IN_COL, ((Expression<?>... | 3.26 |
querydsl_JPAExpressions_max_rdh | /**
* Create a max(col) expression
*
* @param left
* collection
* @return max(col)
*/public static <A extends Comparable<? super A>> ComparableExpression<A> max(CollectionExpression<?, A> left) {
return Expressions.comparableOperation(((Class) (left.getParameter(0))), QuantOps.MAX_IN_COL, ((Expression<?>) (... | 3.26 |
querydsl_JPAExpressions_avg_rdh | /**
* Create a avg(col) expression
*
* @param col
* collection
* @return avg(col)
*/
public static <A extends Comparable<? super A>> ComparableExpression<A> avg(CollectionExpression<?, A> col) {
return Expressions.comparableOperation(((Class) (col.getParameter(0))), QuantOps.AVG_IN_COL, ((Expression<?>) (c... | 3.26 |
querydsl_JTSCurveExpression_startPoint_rdh | /**
* The start Point of this Curve.
*
* @return start point
*/
public JTSPointExpression<Point> startPoint() { if (startPoint == null) {
startPoint = JTSGeometryExpressions.pointOperation(SpatialOps.START_POINT, mixin);
}
return startPoint;
} | 3.26 |
querydsl_JTSCurveExpression_m0_rdh | /**
* The end Point of this Curve.
*
* @return end point
*/ public JTSPointExpression<Point> m0() {
if (endPoint == null) {
endPoint = JTSGeometryExpressions.pointOperation(SpatialOps.END_POINT, mixin);
}
return endPoint;
} | 3.26 |
querydsl_JTSCurveExpression_length_rdh | /**
* The length of this Curve in its associated spatial reference.
*
* @return length
*/
public NumberExpression<Double> length() {
if (length == null) {
length = Expressions.numberOperation(Double.class, SpatialOps.LENGTH, mixin);
}
return length;
} | 3.26 |
querydsl_JTSCurveExpression_isClosed_rdh | /**
* Returns 1 (TRUE) if this Curve is closed [StartPoint ( ) = EndPoint ( )].
*
* @return closed
*/
public BooleanExpression isClosed() {
if (f0 == null) {
f0 = Expressions.booleanOperation(SpatialOps.IS_CLOSED, mixin);
}
return f0;
} | 3.26 |
querydsl_AbstractSQLQuery_forShare_rdh | /**
* FOR SHARE causes the rows retrieved by the SELECT statement to be locked as though for update.
*
* Supported by MySQL, PostgreSQL, SQLServer.
*
* @param fallbackToForUpdate
* if the FOR SHARE is not supported and this parameter is <code>true</code>, the
* {@link #forUpdate()} functionality will be used... | 3.26 |
querydsl_AbstractSQLQuery_startContext_rdh | /**
* Called to create and start a new SQL Listener context
*
* @param connection
* the database connection
* @param metadata
* the meta data for that context
* @return the newly started context
*/
protected SQLListenerContextImpl startContext(Connection connection, QueryMetadata metadata) {
SQLListener... | 3.26 |
querydsl_AbstractSQLQuery_m2_rdh | /**
* Set whether literals are used in SQL strings instead of parameter bindings (default: false)
*
* <p>Warning: When literals are used, prepared statement won't have any parameter bindings
* and also batch statements will only be simulated, but not executed as actual batch statements.</p>
*
* @param useLiterals... | 3.26 |
querydsl_AbstractSQLQuery_addListener_rdh | /**
* Add a listener
*
* @param listener
* listener to add
*/
public void addListener(SQLListener listener) {
listeners.add(listener);} | 3.26 |
querydsl_AbstractSQLQuery_getResults_rdh | /**
* Get the results as a JDBC ResultSet
*
* @return results as ResultSet
*/
public ResultSet getResults() {
final SQLListenerContextImpl v6 = startContext(connection(), queryMixin.getMetadata());
String queryString = null;
List<Object> constants = Collections.emptyList();
try {
listeners.preRender(v6);
SQLSeria... | 3.26 |
querydsl_AbstractSQLQuery_setStatementOptions_rdh | /**
* Set the options to be applied to the JDBC statements of this query
*
* @param statementOptions
* options to be applied to statements
*/
public void setStatementOptions(StatementOptions statementOptions) {
this.statementOptions = statementOptions;
} | 3.26 |
querydsl_AbstractSQLQuery_forUpdate_rdh | /**
* If you use forUpdate() with a backend that uses page or row locks, rows examined by the
* query are write-locked until the end of the current transaction.
*
* Not supported for SQLite and CUBRID
*
* @return the current object
*/
public Q forUpdate() {
QueryFlag forUpdateFlag = configuration.getTempla... | 3.26 |
querydsl_AbstractSQLQuery_onException_rdh | /**
* Called to make the call back to listeners when an exception happens
*
* @param context
* the current context in play
* @param e
* the exception
*/
protected void onException(SQLListenerContextImpl context, Exception e) {
context.setException(e);
listeners.exception(context);
} | 3.26 |
querydsl_AbstractSQLQuery_as_rdh | /**
* Create an alias for the expression
*
* @param alias
* alias
* @return this as alias
*/
@SuppressWarnings("unchecked")
public SimpleExpression<T> as(Path<?>
alias) {
return Expressions.as(this, ((Path) (alias)));
} | 3.26 |
querydsl_LineStringExpression_pointN_rdh | /**
* Returns the specified Point N in this LineString.
*
* @param idx
* one-based index of element
* @return matched element
*/
public PointExpression<Point> pointN(int idx) {
return
GeometryExpressions.pointOperation(SpatialOps.POINTN, mixin, ConstantImpl.create(idx));
} | 3.26 |
querydsl_MapPath_getKeyType_rdh | /**
* Get the key type
*
* @return key type
*/public Class<K> getKeyType() {
return f0;
} | 3.26 |
graphhopper_LocationIndexTree_setMaxRegionSearch_rdh | /**
* Searches also neighbouring tiles until the maximum distance from the query point is reached
* (minResolutionInMeter*regionAround). Set to 1 to only search one tile. Good if you
* have strict performance requirements and want the search to terminate early, and you can tolerate
* that edges that may be in neigh... | 3.26 |
graphhopper_LocationIndexTree_calculateRMin_rdh | /**
* Calculates the distance to the nearest tile border, where the tile border is the rectangular
* region with dimension 2*paddingTiles + 1 and where the center tile contains the given lat/lon
* coordinate
*/
final double calculateRMin(double lat, double lon, int paddingTiles)
{
int x = indexStructureInfo.ge... | 3.26 |
graphhopper_NameSimilarityEdgeFilter_prepareName_rdh | /**
* Removes any characters in the String that we don't care about in the matching procedure
* TODO Currently limited to certain 'western' languages
*/
private String
prepareName(String name) {
StringBuilder sb = new StringBuilder(name.length());
Matcher wordCharMatcher = WORD_CHAR.matcher(name);while (wordCharMatc... | 3.26 |
graphhopper_PrepareLandmarks_setAreaIndex_rdh | /**
*
* @see LandmarkStorage#setAreaIndex(AreaIndex)
*/
public PrepareLandmarks setAreaIndex(AreaIndex<SplitArea> areaIndex) {
lms.setAreaIndex(areaIndex);
return this;
} | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.