mirror of
https://github.com/querydsl/querydsl.git
synced 2026-07-06 21:05:50 +08:00
406 lines
15 KiB
Java
406 lines
15 KiB
Java
package com.mysema.query;
|
|
|
|
import static com.mysema.query.Target.H2;
|
|
import static com.mysema.query.Target.MYSQL;
|
|
import static com.mysema.query.Target.TERADATA;
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertNotNull;
|
|
import static org.junit.Assert.assertTrue;
|
|
|
|
import java.util.List;
|
|
|
|
import org.geolatte.geom.Geometry;
|
|
import org.geolatte.geom.LineString;
|
|
import org.geolatte.geom.MultiLineString;
|
|
import org.geolatte.geom.MultiPoint;
|
|
import org.geolatte.geom.MultiPolygon;
|
|
import org.geolatte.geom.Point;
|
|
import org.geolatte.geom.Polygon;
|
|
import org.geolatte.geom.codec.Wkt;
|
|
import org.junit.Test;
|
|
|
|
import com.google.common.collect.Lists;
|
|
import com.mysema.query.spatial.PointExpression;
|
|
import com.mysema.query.spatial.path.LineStringPath;
|
|
import com.mysema.query.spatial.path.MultiLineStringPath;
|
|
import com.mysema.query.spatial.path.MultiPointPath;
|
|
import com.mysema.query.spatial.path.MultiPolygonPath;
|
|
import com.mysema.query.spatial.path.PointPath;
|
|
import com.mysema.query.spatial.path.PolygonPath;
|
|
import com.mysema.query.sql.spatial.QShapes;
|
|
import com.mysema.query.sql.spatial.Shapes;
|
|
import com.mysema.query.types.ConstantImpl;
|
|
import com.mysema.query.types.Expression;
|
|
import com.mysema.testutil.ExcludeIn;
|
|
|
|
public class SpatialBase extends AbstractBaseTest {
|
|
|
|
private static final QShapes shapes = QShapes.shapes;
|
|
|
|
// point 1-5
|
|
// linestring 6-7
|
|
// polygon 8-9
|
|
// multipoint 10-11
|
|
// multilinestring 12-13
|
|
// multipolygon 14-15
|
|
|
|
private TestQuery withPoints() {
|
|
return query().from(shapes).where(shapes.id.between(1, 5));
|
|
}
|
|
|
|
private TestQuery withLineStrings() {
|
|
return query().from(shapes).where(shapes.id.between(6, 7));
|
|
}
|
|
|
|
private TestQuery withPolygons() {
|
|
return query().from(shapes).where(shapes.id.between(8, 9));
|
|
}
|
|
|
|
private TestQuery withMultipoints() {
|
|
return query().from(shapes).where(shapes.id.between(10, 11));
|
|
}
|
|
|
|
private TestQuery withMultiLineStrings() {
|
|
return query().from(shapes).where(shapes.id.between(12, 13));
|
|
}
|
|
|
|
private TestQuery withMultiPolygons() {
|
|
return query().from(shapes).where(shapes.id.between(14, 15));
|
|
}
|
|
|
|
@Test // FIXME, maybe use enum as the type ?!?
|
|
@ExcludeIn(H2)
|
|
public void GeometryType() {
|
|
List<Tuple> results = query().from(shapes).list(shapes.geometry, shapes.geometry.geometryType());
|
|
assertFalse(results.isEmpty());
|
|
for (Tuple row : results) {
|
|
assertEquals(
|
|
row.get(shapes.geometry).getGeometryType().name(),
|
|
row.get(shapes.geometry.geometryType()));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void AsText() {
|
|
List<Tuple> results = query().from(shapes).list(shapes.geometry, shapes.geometry.asText());
|
|
assertFalse(results.isEmpty());
|
|
for (Tuple row : results) {
|
|
if (!(row.get(shapes.geometry) instanceof MultiPoint)) {
|
|
assertEquals(
|
|
row.get(shapes.geometry).asText().replace(" ", ""),
|
|
row.get(shapes.geometry.asText()).replace(" ", ""));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@ExcludeIn(H2)
|
|
public void Point_X_Y() {
|
|
PointPath<Point> point = new PointPath<Point>(Point.class, shapes, "geometry");
|
|
List<Tuple> results = withPoints().list(point, point.x(), point.y());
|
|
assertFalse(results.isEmpty());
|
|
for (Tuple row : results) {
|
|
assertEquals(Double.valueOf(row.get(point).getX()), row.get(point.x()));
|
|
assertEquals(Double.valueOf(row.get(point).getY()), row.get(point.y()));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void Point_Instances() {
|
|
List<Shapes> results = withPoints().list(shapes);
|
|
assertEquals(5, results.size());
|
|
for (Shapes row : results) {
|
|
assertNotNull(row.getId());
|
|
assertNotNull(row.getGeometry());
|
|
assertTrue(row.getGeometry() instanceof Point);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void LineString_Instances() {
|
|
List<Geometry> results = withLineStrings().list(shapes.geometry);
|
|
assertFalse(results.isEmpty());
|
|
for (Geometry row : results) {
|
|
assertNotNull(row);
|
|
assertTrue(row instanceof LineString);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void Polygon_Instances() {
|
|
List<Geometry> results = withPolygons().list(shapes.geometry);
|
|
assertFalse(results.isEmpty());
|
|
for (Geometry row : results) {
|
|
assertNotNull(row);
|
|
assertTrue(row instanceof Polygon);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void MultiPoint_Instances() {
|
|
List<Geometry> results = withMultipoints().list(shapes.geometry);
|
|
assertFalse(results.isEmpty());
|
|
for (Geometry row : results) {
|
|
assertNotNull(row);
|
|
assertTrue(row instanceof MultiPoint);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void MultiLineString_Instances() {
|
|
List<Geometry> results = withMultiLineStrings().list(shapes.geometry);
|
|
assertFalse(results.isEmpty());
|
|
for (Geometry row : results) {
|
|
assertNotNull(row);
|
|
assertTrue(row instanceof MultiLineString);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void MultiPolygon_Instances() {
|
|
List<Geometry> results = withMultiPolygons().list(shapes.geometry);
|
|
assertFalse(results.isEmpty());
|
|
for (Geometry row : results) {
|
|
assertNotNull(row);
|
|
assertTrue(row instanceof MultiPolygon);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void Point_Methods() {
|
|
PointPath<Point> point = new PointPath<Point>(Point.class, shapes, "geometry");
|
|
|
|
List<Expression<?>> expressions = Lists.newArrayList();
|
|
add(expressions, point.asBinary(), H2);
|
|
add(expressions, point.asText());
|
|
add(expressions, point.boundary(), MYSQL);
|
|
add(expressions, point.convexHull(), MYSQL);
|
|
add(expressions, point.dimension());
|
|
add(expressions, point.envelope(), H2);
|
|
add(expressions, point.geometryType(), H2);
|
|
add(expressions, point.isEmpty());
|
|
add(expressions, point.isSimple());
|
|
add(expressions, point.m(), MYSQL, TERADATA, H2);
|
|
add(expressions, point.srid());
|
|
// point specific
|
|
add(expressions, point.x(), H2);
|
|
add(expressions, point.y(), H2);
|
|
add(expressions, point.z(), MYSQL, TERADATA, H2);
|
|
|
|
for (Expression<?> expr : expressions) {
|
|
boolean logged = false;
|
|
for (Object row : withPoints().list(expr)) {
|
|
if (row == null && !logged) {
|
|
System.err.println(expr.toString());
|
|
logged = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private List<Expression<?>> createExpressions(PointExpression<Point> point1, Expression<Point> point2) {
|
|
List<Expression<?>> expressions = Lists.newArrayList();
|
|
add(expressions, point1.contains(point2));
|
|
add(expressions, point1.crosses(point2));
|
|
add(expressions, point1.difference(point2), MYSQL);
|
|
add(expressions, point1.disjoint(point2));
|
|
add(expressions, point1.distance(point2), MYSQL);
|
|
add(expressions, point1.eq(point2));
|
|
add(expressions, point1.intersection(point2), MYSQL);
|
|
add(expressions, point1.intersects(point2));
|
|
add(expressions, point1.overlaps(point2));
|
|
add(expressions, point1.symDifference(point2), MYSQL);
|
|
add(expressions, point1.touches(point2));
|
|
add(expressions, point1.union(point2), MYSQL);
|
|
add(expressions, point1.within(point2));
|
|
return expressions;
|
|
}
|
|
|
|
@Test
|
|
public void Point_Methods2() {
|
|
QShapes shapes1 = QShapes.shapes;
|
|
PointPath<Point> point1 = new PointPath<Point>(Point.class, shapes1, "geometry");
|
|
|
|
QShapes shapes2 = new QShapes("shapes2");
|
|
PointPath<Point> point2 = new PointPath<Point>(Point.class, shapes2, "geometry");
|
|
|
|
List<Expression<?>> expressions = Lists.newArrayList();
|
|
expressions.addAll(createExpressions(point1, point2));
|
|
expressions.addAll(createExpressions(point1, ConstantImpl.create((Point)Wkt.fromWkt("Point(2 2)"))));
|
|
|
|
for (Expression<?> expr : expressions) {
|
|
boolean logged = false;
|
|
for (Object row : query().from(shapes1, shapes2)
|
|
.where(shapes1.id.loe(5), shapes2.id.loe(5)).list(expr)) {
|
|
if (row == null && !logged) {
|
|
System.err.println(expr.toString());
|
|
logged = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void LineString_Methods() {
|
|
LineStringPath<LineString> lineString = new LineStringPath<LineString>(LineString.class, shapes, "geometry");
|
|
|
|
List<Expression<?>> expressions = Lists.newArrayList();
|
|
add(expressions, lineString.asBinary(), H2);
|
|
add(expressions, lineString.asText());
|
|
add(expressions, lineString.boundary(), MYSQL);
|
|
add(expressions, lineString.convexHull(), MYSQL);
|
|
add(expressions, lineString.dimension());
|
|
add(expressions, lineString.envelope(), H2);
|
|
add(expressions, lineString.geometryType(), H2);
|
|
add(expressions, lineString.isEmpty());
|
|
add(expressions, lineString.isSimple());
|
|
// curve specific
|
|
add(expressions, lineString.length(), H2);
|
|
add(expressions, lineString.startPoint(), H2);
|
|
add(expressions, lineString.endPoint(), H2);
|
|
add(expressions, lineString.isClosed(), H2);
|
|
add(expressions, lineString.isRing(), H2, MYSQL);
|
|
// linestring specific
|
|
add(expressions, lineString.numPoints(), H2);
|
|
add(expressions, lineString.pointN(1), H2);
|
|
|
|
for (Expression<?> expr : expressions) {
|
|
boolean logged = false;
|
|
for (Object row : withLineStrings().list(expr)) {
|
|
if (row == null && !logged) {
|
|
System.err.println(expr.toString());
|
|
logged = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void Polygon_Methods() {
|
|
PolygonPath<Polygon> polygon = new PolygonPath<Polygon>(Polygon.class, shapes, "geometry");
|
|
|
|
List<Expression<?>> expressions = Lists.newArrayList();
|
|
add(expressions, polygon.asBinary(), H2);
|
|
add(expressions, polygon.asText());
|
|
add(expressions, polygon.boundary(), MYSQL);
|
|
add(expressions, polygon.convexHull(), MYSQL);
|
|
add(expressions, polygon.dimension());
|
|
add(expressions, polygon.envelope(), H2);
|
|
add(expressions, polygon.geometryType(), H2);
|
|
add(expressions, polygon.isEmpty());
|
|
add(expressions, polygon.isSimple());
|
|
// surface specific
|
|
add(expressions, polygon.area());
|
|
add(expressions, polygon.centroid());
|
|
add(expressions, polygon.pointOnSurface(), H2, MYSQL);
|
|
// polygon specific
|
|
add(expressions, polygon.exterorRing(), H2);
|
|
add(expressions, polygon.numInteriorRing(), H2);
|
|
add(expressions, polygon.interiorRingN(1), H2);
|
|
|
|
for (Expression<?> expr : expressions) {
|
|
boolean logged = false;
|
|
for (Object row : withPolygons().list(expr)) {
|
|
if (row == null && !logged) {
|
|
System.err.println(expr.toString());
|
|
logged = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void MultiPoint_Methods() {
|
|
MultiPointPath<MultiPoint> multipoint = new MultiPointPath<MultiPoint>(MultiPoint.class, shapes, "geometry");
|
|
|
|
List<Expression<?>> expressions = Lists.newArrayList();
|
|
add(expressions, multipoint.asBinary(), H2);
|
|
add(expressions, multipoint.asText());
|
|
add(expressions, multipoint.boundary(), MYSQL);
|
|
add(expressions, multipoint.convexHull(), MYSQL);
|
|
add(expressions, multipoint.dimension());
|
|
add(expressions, multipoint.envelope(), H2);
|
|
add(expressions, multipoint.geometryType(), H2);
|
|
add(expressions, multipoint.isEmpty());
|
|
add(expressions, multipoint.isSimple());
|
|
// multipoint specific
|
|
add(expressions, multipoint.numGeometries(), H2);
|
|
add(expressions, multipoint.geometryN(1), H2);
|
|
|
|
for (Expression<?> expr : expressions) {
|
|
boolean logged = false;
|
|
for (Object row : withMultipoints().list(expr)) {
|
|
if (row == null && !logged) {
|
|
System.err.println(expr.toString());
|
|
logged = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void MultiLineString_Methods() {
|
|
MultiLineStringPath<MultiLineString> multilinestring = new MultiLineStringPath<MultiLineString>(MultiLineString.class, shapes, "geometry");
|
|
|
|
List<Expression<?>> expressions = Lists.newArrayList();
|
|
add(expressions, multilinestring.asBinary(), H2);
|
|
add(expressions, multilinestring.asText());
|
|
add(expressions, multilinestring.boundary(), MYSQL);
|
|
add(expressions, multilinestring.convexHull(), MYSQL);
|
|
add(expressions, multilinestring.dimension());
|
|
add(expressions, multilinestring.envelope(), H2);
|
|
add(expressions, multilinestring.geometryType(), H2);
|
|
add(expressions, multilinestring.isEmpty());
|
|
add(expressions, multilinestring.isSimple());
|
|
// multicurve specific
|
|
add(expressions, multilinestring.isClosed(), H2);
|
|
add(expressions, multilinestring.length(), H2);
|
|
// multilinestring specific
|
|
add(expressions, multilinestring.numGeometries(), H2);
|
|
add(expressions, multilinestring.geometryN(1), H2);
|
|
|
|
for (Expression<?> expr : expressions) {
|
|
boolean logged = false;
|
|
for (Object row : withMultiLineStrings().list(expr)) {
|
|
if (row == null && !logged) {
|
|
System.err.println(expr.toString());
|
|
logged = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void MultiPolygon_Methods() {
|
|
MultiPolygonPath<MultiPolygon> multipolygon = new MultiPolygonPath<MultiPolygon>(MultiPolygon.class, shapes, "geometry");
|
|
|
|
List<Expression<?>> expressions = Lists.newArrayList();
|
|
add(expressions, multipolygon.asBinary(), H2);
|
|
add(expressions, multipolygon.asText());
|
|
add(expressions, multipolygon.boundary(), MYSQL);
|
|
add(expressions, multipolygon.convexHull(), MYSQL);
|
|
add(expressions, multipolygon.dimension());
|
|
add(expressions, multipolygon.envelope(), H2);
|
|
add(expressions, multipolygon.geometryType(), H2);
|
|
add(expressions, multipolygon.isEmpty());
|
|
add(expressions, multipolygon.isSimple());
|
|
// multipolygon specific
|
|
add(expressions, multipolygon.numGeometries(), H2);
|
|
add(expressions, multipolygon.geometryN(1), H2);
|
|
|
|
for (Expression<?> expr : expressions) {
|
|
boolean logged = false;
|
|
for (Object row : withMultiPolygons().list(expr)) {
|
|
if (row == null && !logged) {
|
|
System.err.println(expr.toString());
|
|
logged = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|