private EXGeographicBoundingBox getGeographicBoundingBox(Envelope env, String epsgCode) {
Envelope newEnvelope;
if ("EPSG:4326".equals(epsgCode)) {
newEnvelope = env;
} else {
try {
GeometryFactory gf = new GeometryFactory();
Polygon poly = (Polygon) gf.toGeometry(env);
ST_Transform transformFunction = new ST_Transform();
CoordinateReferenceSystem inputCRS = DataSourceFactory.getCRSFactory().getCRS(epsgCode);
Value val =
transformFunction.evaluate(
null,
ValueFactory.createValue(poly, inputCRS),
ValueFactory.createValue("EPSG:4326"));
newEnvelope = val.getAsGeometry().getEnvelopeInternal();
} catch (FunctionException fe) {
return getDummyGeographic();
} catch (CRSException ex) {
return getDummyGeographic();
}
}
EXGeographicBoundingBox ret = new EXGeographicBoundingBox();
ret.setEastBoundLongitude(newEnvelope.getMaxX());
ret.setWestBoundLongitude(newEnvelope.getMinX());
ret.setNorthBoundLatitude(newEnvelope.getMaxY());
ret.setSouthBoundLatitude(newEnvelope.getMinY());
return ret;
}
private void testIndexRealData(String source, double checkPeriod, DiskRTree tree)
throws NoSuchTableException, DataSourceCreationException, DriverException, IOException,
Exception {
DataSource ds = dsf.getDataSource(source);
String fieldName = "the_geom";
ds.open();
int fieldIndex = ds.getFieldIndexByName(fieldName);
for (int i = 0; i < ds.getRowCount(); i++) {
if (i / (int) checkPeriod == i / checkPeriod) {
tree.checkTree();
tree.close();
tree.openIndex(indexFile);
tree.checkTree();
checkLookUp(tree, ds, fieldIndex);
}
Envelope value = ds.getFieldValue(i, fieldIndex).getAsGeometry().getEnvelopeInternal();
tree.insert(value, i);
}
for (int i = 0; i < ds.getRowCount(); i++) {
if (i / (int) checkPeriod == i / checkPeriod) {
tree.checkTree();
tree.save();
tree.checkTree();
checkLookUp(tree, ds, fieldIndex);
}
Value value = ds.getFieldValue(i, fieldIndex);
tree.delete(value.getAsGeometry().getEnvelopeInternal(), i);
}
ds.close();
}
public static void failIfNull(Value... values) throws FunctionException {
for (Value value : values) {
if (value.getType() == Type.NULL) {
throw new FunctionException("Cannot operate in null values");
}
}
}
private Value castValue(Type type, Value value) {
Value newValue = value;
if (!value.isNull()
&& type.getTypeCode() != value.getType()
&& TypeFactory.canBeCastTo(value.getType(), type.getTypeCode())) {
newValue = value.toType(type.getTypeCode());
}
return newValue;
}
@Override
public String check(Value value) {
if (!value.isNull()) {
Matcher m = pattern.matcher(value.toString());
if (!m.matches()) {
return "The value doesn't match the pattern '" + constraintValue + "'";
}
}
return null;
}
@Override
public Number[] getScope(int dimension) throws DriverException {
if (cachedScope == null) {
boolean open = isOpen();
if (!open) {
open();
}
for (int i = 0; i < getRowCount(); i++) {
Metadata m = getMetadata();
for (int j = 0; j < m.getFieldCount(); j++) {
int typeCode = m.getFieldType(j).getTypeCode();
Envelope r = null;
if ((typeCode & Type.GEOMETRY) != 0) {
Value v = getFieldValue(i, j);
if ((v != null) && (!v.isNull())) {
r = v.getAsGeometry().getEnvelopeInternal();
}
} else if (typeCode == Type.RASTER) {
Value v = getFieldValue(i, j);
if ((v != null) && (!v.isNull())) {
r = v.getAsRaster().getMetadata().getEnvelope();
}
} else if (typeCode == Type.STREAM) {
Value v = getFieldValue(i, j);
if ((v != null) && (!v.isNull())) {
r = v.getAsStream().getEnvelope();
}
}
if (r != null) {
if (cachedScope == null) {
cachedScope = new Envelope(r);
} else {
cachedScope.expandToInclude(r);
}
}
}
}
if (!open) {
close();
}
}
if (cachedScope == null) {
return new Number[] {0, 0};
} else {
if (dimension == DataSet.X) {
return new Number[] {cachedScope.getMinX(), cachedScope.getMaxX()};
} else if (dimension == DataSet.Y) {
return new Number[] {cachedScope.getMinY(), cachedScope.getMaxY()};
} else {
throw new UnsupportedOperationException("Not yet implemented");
}
}
}
@Override
public String check(int fieldId, Value value) throws DriverException {
// In order to build pk indexes
initializeEdition();
// Check special case of auto-increment not-null fields
Type type = getMetadata().getFieldType(fieldId);
boolean autoIncrement = type.getBooleanConstraint(Constraint.AUTO_INCREMENT);
if (autoIncrement && type.getBooleanConstraint(Constraint.NOT_NULL) && value.isNull()) {
return null;
}
int fieldType = type.getTypeCode();
// Test geometry types.
if (TypeFactory.isVectorial(type.getTypeCode())) {
int valueType = value.getType();
if (!checkGeometry(valueType, fieldType)) {
return "Can't put a "
+ TypeFactory.getTypeName(valueType)
+ " in a "
+ TypeFactory.getTypeName(fieldType)
+ " column.";
}
}
// Cast value
Value val = castValue(type, value);
int broadType = TypeFactory.getBroaderType(fieldType, val.getType());
if (val.getType() != broadType
&& val.getType() != Type.NULL
&& !checkGeometry(val.getType(), fieldType)
&& fieldType != Type.STRING) {
return "Can't cast a "
+ TypeFactory.getTypeName(value.getType())
+ " to a "
+ TypeFactory.getTypeName(fieldType);
}
// Check constraints
String fieldName = getMetadata().getFieldName(fieldId);
String error = type.check(value);
if (error != null) {
return "Value at field " + getFieldName(fieldId) + " is not valid:" + error;
}
// Check uniqueness
if (type.getBooleanConstraint(Constraint.UNIQUE) || type.getBooleanConstraint(Constraint.PK)) {
// We assume a geometry field can't have unique constraint
IndexQuery iq = new DefaultAlphaQuery(fieldName, value);
Iterator<Integer> it = queryIndex(iq);
while (it.hasNext()) {
if (getFieldValue(it.next(), fieldId).equals(value).getAsBoolean()) {
return fieldName + " column doesn't admit duplicates: " + value;
}
}
}
return null;
}
protected Value testSpatialFunction(
ScalarFunction function, int[] valueType, int parameterCount, Value... normalValue)
throws Exception {
// Test null input
ColumnValue[] vals = new ColumnValue[parameterCount];
for (int i = 0; i < parameterCount; i++) {
vals[i] = new ColumnValue(valueType[i], ValueFactory.createNullValue());
}
Value res = evaluate(function, vals);
assertTrue(res.isNull());
// Test too many parameters
Value[] args = new Value[parameterCount + 1];
for (int i = 0; i < args.length; i++) {
args[i] = normalValue[0];
}
try {
res = evaluate(function, args);
fail();
} catch (IncompatibleTypesException e) {
}
// Test wrong parameter type
try {
args = new Value[parameterCount];
for (int i = 0; i < args.length; i++) {
args[i] = ValueFactory.createValue(new Value[0]);
}
res = evaluate(function, args);
fail();
} catch (IncompatibleTypesException e) {
}
// Test normal input value and type
res = evaluate(function, normalValue);
return res;
}
public static void failIfNotOfType(Value value, int type) throws FunctionException {
if (type != value.getType()) {
throw new FunctionException(value.toString() + " is not of type " + type);
}
}