lucene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From no...@apache.org
Subject [36/50] lucene-solr:apiv2: SOLR-8814: Support GeoJSON response format
Date Fri, 18 Mar 2016 08:30:23 GMT
SOLR-8814: Support GeoJSON response format


Project: http://git-wip-us.apache.org/repos/asf/lucene-solr/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucene-solr/commit/36145d02
Tree: http://git-wip-us.apache.org/repos/asf/lucene-solr/tree/36145d02
Diff: http://git-wip-us.apache.org/repos/asf/lucene-solr/diff/36145d02

Branch: refs/heads/apiv2
Commit: 36145d02ccc838f50538a8b9d6ff9c68f3ccce22
Parents: 24830b7
Author: Ryan McKinley <ryan@apache.org>
Authored: Wed Mar 16 09:49:46 2016 -0700
Committer: Ryan McKinley <ryan@apache.org>
Committed: Wed Mar 16 10:06:49 2016 -0700

----------------------------------------------------------------------
 solr/CHANGES.txt                                |  12 +
 .../src/java/org/apache/solr/core/SolrCore.java |   3 +-
 .../solr/response/GeoJSONResponseWriter.java    | 345 +++++++++++++++++++
 .../solr/response/JSONResponseWriter.java       |   2 +-
 .../transform/GeoTransformerFactory.java        | 224 ++++++++++++
 .../response/transform/TransformerFactory.java  |   1 +
 .../response/transform/WriteableGeoJSON.java    |  55 +++
 .../solr/schema/AbstractSpatialFieldType.java   |   7 +
 .../solr/collection1/conf/schema-spatial.xml    |   1 +
 .../response/TestGeoJSONResponseWriter.java     | 279 +++++++++++++++
 10 files changed, 927 insertions(+), 2 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/36145d02/solr/CHANGES.txt
----------------------------------------------------------------------
diff --git a/solr/CHANGES.txt b/solr/CHANGES.txt
index 691e87f..c48032e 100644
--- a/solr/CHANGES.txt
+++ b/solr/CHANGES.txt
@@ -34,6 +34,18 @@ Detailed Change List
 New Features
 ----------------------
 
+* SOLR-8814: Support GeoJSON response writer and general spatial formatting.  Adding
+     &wt=geojson&geojson.field=<your geometry field>
+  Will return a FeatureCollection for each SolrDocumentList and a Feature with the
+  requested geometry for each SolrDocument.  The requested geometry field needs
+  to either extend AbstractSpatialFieldType or store a GeoJSON string.  This also adds
+  a [geo] DocumentTransformer that can return the Shape in a variety of formats:
+    &fl=[geo f=<your geometry field> w=(GeoJSON|WKT|POLY)]
+  The default format is GeoJSON.  For information on the supported formats, see:
+  https://github.com/locationtech/spatial4j/blob/master/FORMATS.md
+  To return the FeatureCollection as the root element, add '&omitHeader=true" (ryan)
+
+
 Bug Fixes
 ----------------------
 

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/36145d02/solr/core/src/java/org/apache/solr/core/SolrCore.java
----------------------------------------------------------------------
diff --git a/solr/core/src/java/org/apache/solr/core/SolrCore.java b/solr/core/src/java/org/apache/solr/core/SolrCore.java
index 7a65a72..c5e54d2 100644
--- a/solr/core/src/java/org/apache/solr/core/SolrCore.java
+++ b/solr/core/src/java/org/apache/solr/core/SolrCore.java
@@ -2123,10 +2123,11 @@ public final class SolrCore implements SolrInfoMBean, Closeable {
   private final PluginBag<QueryResponseWriter> responseWriters = new PluginBag<>(QueryResponseWriter.class,
this);
   public static final Map<String ,QueryResponseWriter> DEFAULT_RESPONSE_WRITERS ;
   static{
-    HashMap<String, QueryResponseWriter> m= new HashMap<>(14, 1);
+    HashMap<String, QueryResponseWriter> m= new HashMap<>(15, 1);
     m.put("xml", new XMLResponseWriter());
     m.put("standard", m.get("xml"));
     m.put(CommonParams.JSON, new JSONResponseWriter());
+    m.put("geojson", new GeoJSONResponseWriter());
     m.put("python", new PythonResponseWriter());
     m.put("php", new PHPResponseWriter());
     m.put("phps", new PHPSerializedResponseWriter());

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/36145d02/solr/core/src/java/org/apache/solr/response/GeoJSONResponseWriter.java
----------------------------------------------------------------------
diff --git a/solr/core/src/java/org/apache/solr/response/GeoJSONResponseWriter.java b/solr/core/src/java/org/apache/solr/response/GeoJSONResponseWriter.java
new file mode 100644
index 0000000..896be92
--- /dev/null
+++ b/solr/core/src/java/org/apache/solr/response/GeoJSONResponseWriter.java
@@ -0,0 +1,345 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.solr.response;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.lucene.index.IndexableField;
+import org.apache.solr.common.SolrDocument;
+import org.apache.solr.common.SolrDocumentList;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.common.SolrException.ErrorCode;
+import org.apache.solr.common.params.CommonParams;
+import org.apache.solr.common.util.NamedList;
+import org.apache.solr.request.SolrQueryRequest;
+import org.apache.solr.response.transform.GeoTransformerFactory;
+import org.apache.solr.response.transform.WriteableGeoJSON;
+import org.apache.solr.schema.AbstractSpatialFieldType;
+import org.apache.solr.schema.SchemaField;
+import org.apache.solr.search.ReturnFields;
+import org.locationtech.spatial4j.context.SpatialContext;
+import org.locationtech.spatial4j.io.ShapeWriter;
+import org.locationtech.spatial4j.io.SupportedFormats;
+import org.locationtech.spatial4j.shape.Shape;
+
+/**
+ * Extend the standard JSONResponseWriter to support GeoJSON.  This writes
+ * a {@link SolrDocumentList} with a 'FeatureCollection', following the
+ * specification in <a href="http://geojson.org/">geojson.org</a>
+ */
+public class GeoJSONResponseWriter extends JSONResponseWriter {
+  
+  public static final String FIELD = "geojson.field";
+  
+  @Override
+  public void write(Writer writer, SolrQueryRequest req, SolrQueryResponse rsp) throws IOException
{
+    
+    String geofield = req.getParams().get(FIELD, null);
+    if(geofield==null || geofield.length()==0) {
+      throw new SolrException(ErrorCode.BAD_REQUEST, "GeoJSON.  Missing parameter: '"+FIELD+"'");
+    }
+    
+    SchemaField sf = req.getSchema().getFieldOrNull(geofield);
+    if(sf==null) {
+      throw new SolrException(ErrorCode.BAD_REQUEST, "GeoJSON.  Unknown field: '"+FIELD+"'="+geofield);
+    }
+    
+    SupportedFormats formats = null;
+    if(sf.getType() instanceof AbstractSpatialFieldType) {
+      SpatialContext ctx = ((AbstractSpatialFieldType)sf.getType()).getSpatialContext();
+      formats = ctx.getFormats();
+    }
+
+    JSONWriter w = new GeoJSONWriter(writer, req, rsp, 
+        geofield,
+        formats); 
+    
+    try {
+      w.writeResponse();
+    } finally {
+      w.close();
+    }
+  }
+}
+
+class GeoJSONWriter extends JSONWriter {
+  
+  final SupportedFormats formats;
+  final ShapeWriter geowriter;
+  final String geofield;
+  
+  public GeoJSONWriter(Writer writer, SolrQueryRequest req, SolrQueryResponse rsp, 
+      String geofield, SupportedFormats formats) {
+    super(writer, req, rsp);
+    this.geofield = geofield;
+    this.formats = formats;
+    if(formats==null) {
+      this.geowriter = null;
+    }
+    else {
+      this.geowriter = formats.getGeoJsonWriter();
+    }
+  }
+
+  @Override
+  public void writeResponse() throws IOException {
+    if(req.getParams().getBool(CommonParams.OMIT_HEADER, false)) {
+      if(wrapperFunction!=null) {
+          writer.write(wrapperFunction + "(");
+      }
+      rsp.removeResponseHeader();
+
+      NamedList<Object> vals = rsp.getValues();
+      Object response = vals.remove("response");
+      if(vals.size()==0) {
+        writeVal(null, response);
+      }
+      else {
+        throw new SolrException(ErrorCode.BAD_REQUEST, 
+            "GeoJSON with "+CommonParams.OMIT_HEADER +
+            " can not return more than a result set");
+      }
+      
+      if(wrapperFunction!=null) {
+        writer.write(')');
+      }
+      writer.write('\n');  // ending with a newline looks much better from the command line
+    }
+    else {
+      super.writeResponse();
+    }
+  }
+  
+  @Override
+  public void writeSolrDocument(String name, SolrDocument doc, ReturnFields returnFields,
int idx) throws IOException {
+    if( idx > 0 ) {
+      writeArraySeparator();
+    }
+
+    indent();
+    writeMapOpener(-1); 
+    incLevel();
+
+    writeKey("type", false);
+    writeVal(null, "Feature");
+    
+    Object val = doc.getFieldValue(geofield);
+    if(val != null) {  
+      writeFeatureGeometry(val);
+    }
+    
+    boolean first=true;
+    for (String fname : doc.getFieldNames()) {
+      if (fname.equals(geofield) || ((returnFields!= null && !returnFields.wantsField(fname))))
{
+        continue;
+      }
+      writeMapSeparator();
+      if (first) {
+        indent();
+        writeKey("properties", false);
+        writeMapOpener(-1); 
+        incLevel();
+        
+        first=false;
+      }
+
+      indent();
+      writeKey(fname, true);
+      val = doc.getFieldValue(fname);
+
+      // SolrDocument will now have multiValued fields represented as a Collection,
+      // even if only a single value is returned for this document.
+      if (val instanceof List) {
+        // shortcut this common case instead of going through writeVal again
+        writeArray(name,((Iterable)val).iterator());
+      } else {
+        writeVal(fname, val);
+      }
+    }
+
+    // GeoJSON does not really support nested FeatureCollections
+    if(doc.hasChildDocuments()) {
+      if(first == false) {
+        writeMapSeparator();
+        indent();
+      }
+      writeKey("_childDocuments_", true);
+      writeArrayOpener(doc.getChildDocumentCount());
+      List<SolrDocument> childDocs = doc.getChildDocuments();
+      for(int i=0; i<childDocs.size(); i++) {
+        writeSolrDocument(null, childDocs.get(i), null, i);
+      }
+      writeArrayCloser();
+    }
+
+    // check that we added any properties
+    if(!first) {
+      decLevel();
+      writeMapCloser();
+    }
+    
+    decLevel();
+    writeMapCloser();
+  }
+
+  protected void writeFeatureGeometry(Object geo) throws IOException 
+  {
+    // Support multi-valued geometries
+    if(geo instanceof Iterable) {
+      Iterator iter = ((Iterable)geo).iterator();
+      if(!iter.hasNext()) {
+        return; // empty list
+      }
+      else {
+        geo = iter.next();
+        
+        // More than value
+        if(iter.hasNext()) {
+          writeMapSeparator();
+          indent();
+          writeKey("geometry", false);
+          incLevel();
+
+          // TODO: in the future, we can be smart and try to make this the appropriate MULTI*
value
+          // if all the values are the same
+          // { "type": "GeometryCollection",
+          //    "geometries": [
+          writeMapOpener(-1); 
+          writeKey("type",false);
+          writeStr(null, "GeometryCollection", false);
+          writeMapSeparator();
+          writeKey("geometries", false);
+          writeArrayOpener(-1); // no trivial way to determine array size
+          incLevel();
+          
+          // The first one
+          indent();
+          writeGeo(geo);
+          while(iter.hasNext()) {
+            // Each element in the array
+            writeArraySeparator();
+            indent();
+            writeGeo(iter.next());
+          }
+          
+          decLevel();
+          writeArrayCloser();
+          writeMapCloser();
+          
+          decLevel();
+          return;
+        }
+      }
+    }
+    
+    // Single Value
+    if(geo!=null) {
+      writeMapSeparator();
+      indent();
+      writeKey("geometry", false);
+      writeGeo(geo);
+    }
+  }
+
+  protected void writeGeo(Object geo) throws IOException {
+    Shape shape = null;
+    String str = null;
+    if(geo instanceof Shape) {
+      shape = (Shape)geo;
+    }
+    else if(geo instanceof IndexableField) {
+      str = ((IndexableField)geo).stringValue();
+    }
+    else if(geo instanceof WriteableGeoJSON) {
+      shape = ((WriteableGeoJSON)geo).shape;
+    }
+    else {
+      str = geo.toString();
+    }
+    
+    if(str !=null) {
+      // Assume it is well formed JSON
+      if(str.startsWith("{") && str.endsWith("}")) {
+        writer.write(str);
+        return;
+      }
+      
+      if(formats==null) {
+        // The check is here and not in the constructor because we do not know if the
+        // *stored* values for the field look like JSON until we actually try to read them
+        throw new SolrException(ErrorCode.BAD_REQUEST, 
+            "GeoJSON unable to write field: '&"+ GeoJSONResponseWriter.FIELD +"="+geofield+"'
("+str+")");
+      }
+      shape = formats.read(str); 
+    }
+    
+    if(geowriter==null) {
+      throw new SolrException(ErrorCode.BAD_REQUEST, 
+          "GeoJSON unable to write field: '&"+ GeoJSONResponseWriter.FIELD +"="+geofield+"'");
+    }
+    
+    if(shape!=null) {
+      geowriter.write(writer, shape);
+    }
+  }
+
+  @Override
+  public void writeStartDocumentList(String name, 
+      long start, int size, long numFound, Float maxScore) throws IOException
+  {
+    writeMapOpener((maxScore==null) ? 3 : 4);
+    incLevel();
+    writeKey("type",false);
+    writeStr(null, "FeatureCollection", false);
+    writeMapSeparator();
+    writeKey("numFound",false);
+    writeLong(null,numFound);
+    writeMapSeparator();
+    writeKey("start",false);
+    writeLong(null,start);
+
+    if (maxScore!=null) {
+      writeMapSeparator();
+      writeKey("maxScore",false);
+      writeFloat(null,maxScore);
+    }
+    writeMapSeparator();
+    
+    // if can we get bbox of all results, we should write it here
+    
+    // indent();
+    writeKey("features",false);
+    writeArrayOpener(size);
+
+    incLevel();
+  }
+
+  @Override
+  public void writeEndDocumentList() throws IOException
+  {
+    decLevel();
+    writeArrayCloser();
+
+    decLevel();
+    indent();
+    writeMapCloser();
+  }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/36145d02/solr/core/src/java/org/apache/solr/response/JSONResponseWriter.java
----------------------------------------------------------------------
diff --git a/solr/core/src/java/org/apache/solr/response/JSONResponseWriter.java b/solr/core/src/java/org/apache/solr/response/JSONResponseWriter.java
index cf894b8..d257f57 100644
--- a/solr/core/src/java/org/apache/solr/response/JSONResponseWriter.java
+++ b/solr/core/src/java/org/apache/solr/response/JSONResponseWriter.java
@@ -70,8 +70,8 @@ public class JSONResponseWriter implements QueryResponseWriter {
 }
 
 class JSONWriter extends TextResponseWriter {
+  protected String wrapperFunction;
   private String namedListStyle;
-  private String wrapperFunction;
 
   private static final String JSON_NL_STYLE="json.nl";
   private static final String JSON_NL_MAP="map";

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/36145d02/solr/core/src/java/org/apache/solr/response/transform/GeoTransformerFactory.java
----------------------------------------------------------------------
diff --git a/solr/core/src/java/org/apache/solr/response/transform/GeoTransformerFactory.java
b/solr/core/src/java/org/apache/solr/response/transform/GeoTransformerFactory.java
new file mode 100644
index 0000000..7b7974b
--- /dev/null
+++ b/solr/core/src/java/org/apache/solr/response/transform/GeoTransformerFactory.java
@@ -0,0 +1,224 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.response.transform;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import org.apache.lucene.index.IndexableField;
+import org.apache.lucene.queries.function.ValueSource;
+import org.apache.lucene.search.MatchAllDocsQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.spatial.SpatialStrategy;
+import org.apache.lucene.spatial.composite.CompositeSpatialStrategy;
+import org.apache.lucene.spatial.serialized.SerializedDVStrategy;
+import org.apache.solr.common.SolrDocument;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.common.SolrException.ErrorCode;
+import org.apache.solr.common.params.SolrParams;
+import org.apache.solr.request.SolrQueryRequest;
+import org.apache.solr.response.JSONResponseWriter;
+import org.apache.solr.response.QueryResponseWriter;
+import org.apache.solr.schema.AbstractSpatialFieldType;
+import org.apache.solr.schema.SchemaField;
+import org.apache.solr.search.QParser;
+import org.apache.solr.search.SyntaxError;
+import org.locationtech.spatial4j.io.GeoJSONWriter;
+import org.locationtech.spatial4j.io.ShapeWriter;
+import org.locationtech.spatial4j.io.SupportedFormats;
+import org.locationtech.spatial4j.shape.Shape;
+
+
+/**
+ * This DocumentTransformer will write a {@link Shape} to the SolrDocument using
+ * the requested format.  Supported formats include:
+ * <ul>
+ *  <li>GeoJSON</li>
+ *  <li>WKT</li>
+ *  <li>Polyshape</li>
+ * </ul>
+ * For more information see: <a href="https://github.com/locationtech/spatial4j/blob/master/FORMATS.md">spatial4j/FORMATS.md</a>
+ * 
+ * The shape is either read from a stored field, or a ValueSource.
+ * 
+ * This transformer is useful when:
+ * <ul>
+ *  <li>You want to return a format different than the stored encoding (WKT vs GeoJSON)</li>
+ *  <li>The {@link Shape} is stored in a {@link ValueSource}, not a stored field</li>
+ *  <li>the value is not stored in a format the output understands (ie, raw GeoJSON)</li>
+ * </ul>
+ * 
+ */
+public class GeoTransformerFactory extends TransformerFactory
+{ 
+  @Override
+  public DocTransformer create(String display, SolrParams params, SolrQueryRequest req) {
+
+    String fname = params.get("f", display);
+    if(fname.startsWith("[") && fname.endsWith("]")) {
+      fname = display.substring(1,display.length()-1);
+    }
+    SchemaField sf = req.getSchema().getFieldOrNull(fname);
+    if(sf==null) {
+      throw new SolrException(ErrorCode.BAD_REQUEST, 
+          this.getClass().getSimpleName() +" using unknown field: "+fname);
+    }
+    if(!(sf.getType() instanceof AbstractSpatialFieldType)) {
+      throw new SolrException(ErrorCode.BAD_REQUEST, 
+          "GeoTransformer requested non-spatial field: "+fname + " ("+sf.getType().getClass().getSimpleName()+")");
+    }
+
+    final GeoFieldUpdater updater = new GeoFieldUpdater();
+    updater.field = fname;
+    updater.display = display;
+    updater.display_error = display+"_error"; 
+        
+    ValueSource shapes = null;
+    AbstractSpatialFieldType<?> sdv = (AbstractSpatialFieldType<?>)sf.getType();
+    SpatialStrategy strategy = sdv.getStrategy(fname);
+    if(strategy instanceof CompositeSpatialStrategy) {
+      shapes = ((CompositeSpatialStrategy)strategy)
+          .getGeometryStrategy().makeShapeValueSource();
+    }
+    else if(strategy instanceof SerializedDVStrategy) {
+      shapes = ((SerializedDVStrategy)strategy)
+          .makeShapeValueSource();
+    }
+    
+    
+    String writerName = params.get("w", "GeoJSON");
+    updater.formats = strategy.getSpatialContext().getFormats();
+    updater.writer = updater.formats.getWriter(writerName);
+    if(updater.writer==null) {
+      StringBuilder str = new StringBuilder();
+      str.append( "Unknown Spatial Writer: " ).append(writerName);
+      str.append(" [");
+      for(ShapeWriter w : updater.formats.getWriters()) {
+        str.append(w.getFormatName()).append(' ');
+      }
+      str.append("]");
+      throw new SolrException(ErrorCode.BAD_REQUEST, str.toString());
+    }
+    
+    QueryResponseWriter qw = req.getCore().getQueryResponseWriter(req);
+    updater.isJSON =
+        (qw.getClass() == JSONResponseWriter.class) &&
+        (updater.writer instanceof GeoJSONWriter);
+
+
+    // Using ValueSource
+    if(shapes!=null) {
+      // we don't really need the qparser... just so we can reuse valueSource
+      QParser parser = new QParser(null,null,params, req) {
+        @Override
+        public Query parse() throws SyntaxError {
+          return new MatchAllDocsQuery();
+        }
+      }; 
+
+      return new ValueSourceAugmenter(display, parser, shapes) {
+        @Override
+        protected void setValue(SolrDocument doc, Object val) {
+          updater.setValue(doc, val);
+        }
+      };
+    }
+    
+    // Using the raw stored values
+    return new DocTransformer() {
+      
+      @Override
+      public void transform(SolrDocument doc, int docid, float score) throws IOException
{
+        Object val = doc.remove(updater.field);
+        if(val!=null) {
+          updater.setValue(doc, val);
+        }
+      }
+      
+      @Override
+      public String getName() {
+        return updater.display;
+      }
+
+      @Override
+      public String[] getExtraRequestFields() {
+        return new String[] {updater.field};
+      }
+    };
+  }
+}
+
+class GeoFieldUpdater {
+  String field;
+  String display;
+  String display_error;
+  
+  boolean isJSON;
+  ShapeWriter writer;
+  SupportedFormats formats;
+  
+  void addShape(SolrDocument doc, Shape shape) {
+    if(isJSON) {
+      doc.addField(display, new WriteableGeoJSON(shape, writer));
+    }
+    else {
+      doc.addField(display, writer.toString(shape));
+    }
+  }
+  
+  void setValue(SolrDocument doc, Object val) {
+    doc.remove(display);
+    if(val != null) {
+      if(val instanceof Iterable) {
+        Iterator iter = ((Iterable)val).iterator();
+        while(iter.hasNext()) {
+          addValue(doc, iter.next());
+        }
+      }
+      else {
+        addValue(doc, val);
+      }
+    }
+  }
+    
+  void addValue(SolrDocument doc, Object val) {
+    if(val == null) {
+      return;
+    }
+    
+    if(val instanceof Shape) {
+      addShape(doc, (Shape)val);
+    }
+    // Don't explode on 'InvalidShpae'
+    else if( val instanceof Exception) {
+      doc.setField( display_error, ((Exception)val).toString() );
+    }
+    else {
+      // Use the stored value
+      if(val instanceof IndexableField) {
+        val = ((IndexableField)val).stringValue();
+      }
+      try {
+        addShape(doc, formats.read(val.toString()));
+      }
+      catch(Exception ex) {
+        doc.setField( display_error, ex.toString() );
+      }
+    }
+  }
+}
+

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/36145d02/solr/core/src/java/org/apache/solr/response/transform/TransformerFactory.java
----------------------------------------------------------------------
diff --git a/solr/core/src/java/org/apache/solr/response/transform/TransformerFactory.java
b/solr/core/src/java/org/apache/solr/response/transform/TransformerFactory.java
index a600adf..6e7a3dd 100644
--- a/solr/core/src/java/org/apache/solr/response/transform/TransformerFactory.java
+++ b/solr/core/src/java/org/apache/solr/response/transform/TransformerFactory.java
@@ -49,5 +49,6 @@ public abstract class TransformerFactory implements NamedListInitializedPlugin
     defaultFactories.put( "child", new ChildDocTransformerFactory() );
     defaultFactories.put( "json", new RawValueTransformerFactory("json") );
     defaultFactories.put( "xml", new RawValueTransformerFactory("xml") );
+    defaultFactories.put( "geo", new GeoTransformerFactory() );
   }
 }

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/36145d02/solr/core/src/java/org/apache/solr/response/transform/WriteableGeoJSON.java
----------------------------------------------------------------------
diff --git a/solr/core/src/java/org/apache/solr/response/transform/WriteableGeoJSON.java b/solr/core/src/java/org/apache/solr/response/transform/WriteableGeoJSON.java
new file mode 100644
index 0000000..40acebf
--- /dev/null
+++ b/solr/core/src/java/org/apache/solr/response/transform/WriteableGeoJSON.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.response.transform;
+
+import java.io.IOException;
+
+import org.apache.solr.common.util.JavaBinCodec;
+import org.apache.solr.response.TextResponseWriter;
+import org.apache.solr.response.WriteableValue;
+import org.locationtech.spatial4j.io.ShapeWriter;
+import org.locationtech.spatial4j.shape.Shape;
+
+/**
+ * This will let the writer add values to the response directly
+ */
+public class WriteableGeoJSON extends WriteableValue {
+
+  public final Shape shape;
+  public final ShapeWriter jsonWriter;
+  
+  public WriteableGeoJSON(Shape shape, ShapeWriter jsonWriter) {
+    this.shape = shape;
+    this.jsonWriter = jsonWriter;
+  }
+
+  @Override
+  public Object resolve(Object o, JavaBinCodec codec) throws IOException {
+    codec.writeStr(jsonWriter.toString(shape));
+    return null; // this means we wrote it
+  }
+
+  @Override
+  public void write(String name, TextResponseWriter writer) throws IOException {
+    jsonWriter.write(writer.getWriter(), shape);
+  }
+
+  @Override
+  public String toString() {
+    return jsonWriter.toString(shape);
+  }
+}

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/36145d02/solr/core/src/java/org/apache/solr/schema/AbstractSpatialFieldType.java
----------------------------------------------------------------------
diff --git a/solr/core/src/java/org/apache/solr/schema/AbstractSpatialFieldType.java b/solr/core/src/java/org/apache/solr/schema/AbstractSpatialFieldType.java
index 222f0b8..e5fd8c6 100644
--- a/solr/core/src/java/org/apache/solr/schema/AbstractSpatialFieldType.java
+++ b/solr/core/src/java/org/apache/solr/schema/AbstractSpatialFieldType.java
@@ -390,6 +390,13 @@ public abstract class AbstractSpatialFieldType<T extends SpatialStrategy>
extend
     }
   }
 
+  /**
+   * @return The Spatial Context for this field type
+   */
+  public SpatialContext getSpatialContext() {
+    return ctx;
+  }
+
   @Override
   public void write(TextResponseWriter writer, String name, IndexableField f) throws IOException
{
     writer.writeStr(name, f.stringValue(), true);

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/36145d02/solr/core/src/test-files/solr/collection1/conf/schema-spatial.xml
----------------------------------------------------------------------
diff --git a/solr/core/src/test-files/solr/collection1/conf/schema-spatial.xml b/solr/core/src/test-files/solr/collection1/conf/schema-spatial.xml
index 2c1ca1f..15837f3 100644
--- a/solr/core/src/test-files/solr/collection1/conf/schema-spatial.xml
+++ b/solr/core/src/test-files/solr/collection1/conf/schema-spatial.xml
@@ -70,6 +70,7 @@
     <field name="bbox" type="bbox" />
 
     <dynamicField name="bboxD_*" type="bbox" indexed="true" />
+    <dynamicField name="str_*" type="string" indexed="true" stored="true"/>
 
   </fields>
 

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/36145d02/solr/core/src/test/org/apache/solr/response/TestGeoJSONResponseWriter.java
----------------------------------------------------------------------
diff --git a/solr/core/src/test/org/apache/solr/response/TestGeoJSONResponseWriter.java b/solr/core/src/test/org/apache/solr/response/TestGeoJSONResponseWriter.java
new file mode 100644
index 0000000..191136b
--- /dev/null
+++ b/solr/core/src/test/org/apache/solr/response/TestGeoJSONResponseWriter.java
@@ -0,0 +1,279 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.response;
+
+import java.lang.invoke.MethodHandles;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.solr.SolrTestCaseJ4;
+import org.apache.solr.common.SolrException;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.locationtech.spatial4j.context.SpatialContext;
+import org.locationtech.spatial4j.io.SupportedFormats;
+import org.locationtech.spatial4j.shape.Shape;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class TestGeoJSONResponseWriter extends SolrTestCaseJ4 {
+  private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
+  final ObjectMapper jsonmapper = new ObjectMapper();
+  
+  @BeforeClass
+  public static void beforeClass() throws Exception {
+    initCore("solrconfig-basic.xml","schema-spatial.xml");
+    createIndex();
+  }
+
+  public static void createIndex() {
+
+
+//    <field name="srpt_geohash" type="srpt_geohash" multiValued="true" />
+//    <field name="" type="srpt_quad" multiValued="true" />
+//    <field name="" type="srpt_packedquad" multiValued="true" />
+//    <field name="" type="stqpt_geohash" multiValued="true" />
+    
+    // multiple valued field
+    assertU(adoc("id","H.A", "srpt_geohash","POINT( 1 2 )"));
+    assertU(adoc("id","H.B", "srpt_geohash","POINT( 1 2 )", 
+                             "srpt_geohash","POINT( 3 4 )"));
+    assertU(adoc("id","H.C", "srpt_geohash","LINESTRING (30 10, 10 30, 40 40)"));
+
+    assertU(adoc("id","Q.A", "srpt_quad","POINT( 1 2 )"));
+    assertU(adoc("id","Q.B", "srpt_quad","POINT( 1 2 )", 
+                             "srpt_quad","POINT( 3 4 )"));
+    assertU(adoc("id","Q.C", "srpt_quad","LINESTRING (30 10, 10 30, 40 40)"));
+
+    assertU(adoc("id","P.A", "srpt_packedquad","POINT( 1 2 )"));
+    assertU(adoc("id","P.B", "srpt_packedquad","POINT( 1 2 )", 
+                             "srpt_packedquad","POINT( 3 4 )"));
+    assertU(adoc("id","P.C", "srpt_packedquad","LINESTRING (30 10, 10 30, 40 40)"));
+
+    
+    // single valued field
+    assertU(adoc("id","R.A", "srptgeom","POINT( 1 2 )"));
+
+    // non-spatial field
+    assertU(adoc("id","S.X", "str_shape","POINT( 1 2 )"));
+    assertU(adoc("id","S.A", "str_shape","{\"type\":\"Point\",\"coordinates\":[1,2]}"));
+    
+
+    assertU(commit());
+  }
+
+  protected Map<String,Object> readJSON(String json) {
+    try {
+      return jsonmapper.readValue(json, Map.class);
+    }
+    catch(Exception ex) {
+      log.warn("Unable to read GeoJSON From: {}", json);
+      log.warn("Error", ex);
+      fail("Unable to parse JSON GeoJSON Response");
+    }
+    return null; 
+  }
+  
+  protected Map<String,Object> getFirstFeatureGeometry(Map<String,Object> json)
+  {
+    Map<String,Object> rsp = (Map<String,Object>)json.get("response");
+    assertEquals("FeatureCollection", rsp.get("type"));
+    List<Object> vals = (List<Object>)rsp.get("features");
+    assertEquals(1, vals.size());
+    Map<String,Object> feature = (Map<String,Object>)vals.get(0);
+    assertEquals("Feature", feature.get("type"));
+    return (Map<String,Object>)feature.get("geometry");
+  }
+
+  @Test
+  public void testRequestExceptions() throws Exception {
+    
+    // Make sure we select the field
+    try {
+      h.query(req(
+        "q","*:*", 
+        "wt","geojson", 
+        "fl","*"));
+      fail("should Require a parameter to select the field");
+    }
+    catch(SolrException ex) {}
+    
+
+    // non-spatial fields *must* be stored as JSON
+    try {
+      h.query(req(
+        "q","id:S.X", 
+        "wt","geojson", 
+        "fl","*",
+        "geojson.field", "str_shape"));
+      fail("should complain about bad shape config");
+    }
+    catch(SolrException ex) {}
+    
+  }
+
+  @Test
+  public void testGeoJSONAtRoot() throws Exception {
+    
+    // Try reading the whole resposne
+    String json = h.query(req(
+        "q","*:*", 
+        "wt","geojson", 
+        "rows","2", 
+        "fl","*", 
+        "geojson.field", "stqpt_geohash",
+        "indent","true"));
+    
+    // Check that we have a normal solr response with 'responseHeader' and 'response'
+    Map<String,Object> rsp = readJSON(json);
+    assertNotNull(rsp.get("responseHeader"));
+    assertNotNull(rsp.get("response"));
+    
+    json = h.query(req(
+        "q","*:*", 
+        "wt","geojson", 
+        "rows","2", 
+        "fl","*", 
+        "omitHeader", "true",
+        "geojson.field", "stqpt_geohash",
+        "indent","true"));
+    
+    // Check that we have a normal solr response with 'responseHeader' and 'response'
+    rsp = readJSON(json);
+    assertNull(rsp.get("responseHeader"));
+    assertNull(rsp.get("response"));
+    assertEquals("FeatureCollection", rsp.get("type"));
+    assertNotNull(rsp.get("features"));
+  }
+  
+  @Test
+  public void testGeoJSONOutput() throws Exception {
+    
+    // Try reading the whole resposne
+    readJSON(h.query(req(
+        "q","*:*", 
+        "wt","geojson", 
+        "fl","*", 
+        "geojson.field", "stqpt_geohash",
+        "indent","true")));
+    
+    // Multivalued Valued Point
+    Map<String,Object> json = readJSON(h.query(req(
+        "q","id:H.B", 
+        "wt","geojson", 
+        "fl","*", 
+        "geojson.field", "srpt_geohash",
+        "indent","true")));
+    
+    Map<String,Object> geo = getFirstFeatureGeometry(json);
+    assertEquals( // NOTE: not actual JSON, it is Map.toString()!
+        "{type=GeometryCollection, geometries=["
+        + "{type=Point, coordinates=[1, 2]}, "
+        + "{type=Point, coordinates=[3, 4]}]}", ""+geo);  
+    
+    
+    // Check the same value encoded on different field types
+    String[][] check = new String[][] {
+      { "id:H.A", "srpt_geohash" },
+      { "id:Q.A", "srpt_quad" },
+      { "id:P.A", "srpt_packedquad" },
+      { "id:R.A", "srptgeom" },
+      { "id:S.A", "str_shape" },
+    };
+    
+    for(String[] args : check) {
+      json = readJSON(h.query(req(
+          "q",args[0], 
+          "wt","geojson", 
+          "fl","*", 
+          "geojson.field", args[1])));
+      
+      geo = getFirstFeatureGeometry(json);
+      assertEquals( 
+        "Error reading point from: "+args[1] + " ("+args[0]+")",
+        // NOTE: not actual JSON, it is Map.toString()!
+        "{type=Point, coordinates=[1, 2]}", ""+geo);  
+    }
+  }
+  
+  protected Map<String,Object> readFirstDoc(String json)
+  {
+    List docs = (List)((Map)readJSON(json).get("response")).get("docs");
+    return (Map)docs.get(0);
+  }
+  
+  public static String normalizeMapToJSON(String val) {
+    val = val.replace("\"", ""); // remove quotes
+    val = val.replace(':', '=');
+    val = val.replace(", ", ",");
+    return val;
+  }
+
+  @Test
+  public void testTransformToAllFormats() throws Exception {
+    
+    String wkt = "POINT( 1 2 )";
+    SupportedFormats fmts = SpatialContext.GEO.getFormats();
+    Shape shape = fmts.read(wkt);
+    
+    String[] check = new String[] {
+        "srpt_geohash",
+        "srpt_geohash",
+        "srpt_quad",
+        "srpt_packedquad",
+        "srptgeom",
+ //       "str_shape",  // NEEDS TO BE A SpatialField!
+    };
+    
+    String[] checkFormats = new String[] {
+        "GeoJSON",
+        "WKT",
+        "POLY"
+    };
+    
+    for(String field : check) {
+      // Add a document with the given field
+      assertU(adoc("id","test", 
+          field, wkt));
+      assertU(commit());
+      
+      
+      for(String fmt : checkFormats) {
+        String json = h.query(req(
+            "q","id:test", 
+            "wt","json", 
+            "indent", "true",
+            "fl","xxx:[geo f="+field+" w="+fmt+"]"
+            ));
+        
+        Map<String,Object> doc = readFirstDoc(json);
+        Object v = doc.get("xxx");
+        String expect = fmts.getWriter(fmt).toString(shape);
+        
+        if(!(v instanceof String)) {
+          v = normalizeMapToJSON(v.toString());
+          expect = normalizeMapToJSON(expect);
+        }
+        
+        assertEquals("Bad result: "+field+"/"+fmt, expect, v.toString());
+      }
+    }
+  }
+}


Mime
View raw message