From 4e30b2e84b3ea18d56e2a5328d232e190e1c71c5 Mon Sep 17 00:00:00 2001
From: Alan Woodward <romseygeek@apache.org>
Date: Wed, 14 Apr 2021 11:09:49 +0100
Subject: [PATCH 1/4] broekn

---
 .../mapper/AbstractGeometryFieldMapper.java   | 63 +++++++------
 .../index/mapper/GeoPointFieldMapper.java     | 43 ++++++++-
 .../mapper/GeoPointScriptMapperTests.java     | 90 +++++++++++++++++++
 3 files changed, 165 insertions(+), 31 deletions(-)
 create mode 100644 server/src/test/java/org/elasticsearch/index/mapper/GeoPointScriptMapperTests.java

diff --git a/server/src/main/java/org/elasticsearch/index/mapper/AbstractGeometryFieldMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/AbstractGeometryFieldMapper.java
index 1f2015eec88b3..ce3a7167d4d04 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/AbstractGeometryFieldMapper.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/AbstractGeometryFieldMapper.java
@@ -174,7 +174,9 @@ protected void parseCreateField(ParseContext context) throws IOException {
     @Override
     public void parse(ParseContext context) throws IOException {
         MappedFieldType mappedFieldType = fieldType();
-
+        if (hasScript) {
+            throw new IllegalArgumentException("Cannot index data directly into a field with a [script] parameter");
+        }
         try {
             Processed shape = context.parseExternalValue(indexer.processedClass());
             if (shape == null) {
@@ -185,33 +187,8 @@ public void parse(ParseContext context) throws IOException {
                 shape = indexer.prepareForIndexing(geometry);
             }
 
-            List<IndexableField> fields = new ArrayList<>();
-            if (mappedFieldType.isSearchable() || mappedFieldType.hasDocValues()) {
-                fields.addAll(indexer.indexShape(context, shape));
-            }
-
-            // indexed:
-            List<IndexableField> indexedFields = new ArrayList<>();
-            if (mappedFieldType.isSearchable()) {
-                indexedFields.addAll(fields);
-            }
-            // stored:
-            if (fieldType().isStored()) {
-                addStoredFields(context, shape);
-            }
-            // docValues:
-            if (fieldType().hasDocValues()) {
-                addDocValuesFields(mappedFieldType.name(), shape, fields, context);
-            } else if (fieldType().isStored() || fieldType().isSearchable()) {
-                createFieldNamesField(context);
-            }
-
-            // add the indexed fields to the doc:
-            for (IndexableField field : indexedFields) {
-                context.doc().add(field);
-            }
-
-            // add multifields (e.g., used for completion suggester)
+            indexValue(context, shape);
+            // Add MultiFields (eg used for completion suggester)
             addMultiFields(context, shape);
         } catch (Exception e) {
             if (ignoreMalformed.value() == false) {
@@ -222,6 +199,36 @@ public void parse(ParseContext context) throws IOException {
         }
     }
 
+    protected void indexValue(ParseContext context, Processed shape) {
+
+        List<IndexableField> fields = new ArrayList<>();
+        if (mappedFieldType.isSearchable() || mappedFieldType.hasDocValues()) {
+            fields.addAll(indexer.indexShape(context, shape));
+        }
+
+        // indexed:
+        List<IndexableField> indexedFields = new ArrayList<>();
+        if (mappedFieldType.isSearchable()) {
+            indexedFields.addAll(fields);
+        }
+        // stored:
+        if (fieldType().isStored()) {
+            addStoredFields(context, shape);
+        }
+        // docValues:
+        if (fieldType().hasDocValues()) {
+            addDocValuesFields(mappedFieldType.name(), shape, fields, context);
+        } else if (fieldType().isStored() || fieldType().isSearchable()) {
+            createFieldNamesField(context);
+        }
+
+        // add the indexed fields to the doc:
+        for (IndexableField field : indexedFields) {
+            context.doc().add(field);
+        }
+
+    }
+
     public boolean ignoreMalformed() {
         return ignoreMalformed.value();
     }
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/GeoPointFieldMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/GeoPointFieldMapper.java
index f8c9b84c0d8a0..bef3dc423139b 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/GeoPointFieldMapper.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/GeoPointFieldMapper.java
@@ -12,6 +12,7 @@
 import org.apache.lucene.document.StoredField;
 import org.apache.lucene.geo.LatLonGeometry;
 import org.apache.lucene.index.IndexableField;
+import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.search.IndexOrDocValuesQuery;
 import org.apache.lucene.search.MatchNoDocsQuery;
 import org.apache.lucene.search.Query;
@@ -28,7 +29,11 @@
 import org.elasticsearch.index.fielddata.plain.AbstractLatLonPointIndexFieldData;
 import org.elasticsearch.index.mapper.GeoPointFieldMapper.ParsedGeoPoint;
 import org.elasticsearch.index.query.SearchExecutionContext;
+import org.elasticsearch.script.GeoPointFieldScript;
+import org.elasticsearch.script.Script;
+import org.elasticsearch.script.ScriptCompiler;
 import org.elasticsearch.search.aggregations.support.CoreValuesSourceType;
+import org.elasticsearch.search.lookup.FieldValues;
 import org.elasticsearch.search.lookup.SearchLookup;
 
 import java.io.IOException;
@@ -37,6 +42,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.function.Supplier;
 
 /**
@@ -60,15 +66,29 @@ public static class Builder extends FieldMapper.Builder {
         final Parameter<Boolean> indexed = Parameter.indexParam(m -> builder(m).indexed.get(), true);
         final Parameter<Boolean> hasDocValues = Parameter.docValuesParam(m -> builder(m).hasDocValues.get(), true);
         final Parameter<Boolean> stored = Parameter.storeParam(m -> builder(m).stored.get(), false);
+        private final Parameter<Script> script = Parameter.scriptParam(m -> builder(m).script.get());
+        private final Parameter<String> onScriptError = Parameter.onScriptErrorParam(m -> builder(m).onScriptError.get(), script);
         final Parameter<Map<String, String>> meta = Parameter.metaParam();
 
-        public Builder(String name, boolean ignoreMalformedByDefault) {
+        private final ScriptCompiler scriptCompiler;
+
+        public Builder(String name, ScriptCompiler scriptCompiler, boolean ignoreMalformedByDefault) {
             super(name);
             this.ignoreMalformed = ignoreMalformedParam(m -> builder(m).ignoreMalformed.get(), ignoreMalformedByDefault);
             this.nullValue = nullValueParam(
                 m -> builder(m).nullValue.get(),
                 (n, c, o) -> parseNullValue(o, ignoreZValue.get().value(), ignoreMalformed.get().value()),
                 () -> null).acceptsNull();
+            this.scriptCompiler = Objects.requireNonNull(scriptCompiler);
+            this.script.precludesParameters(nullValue, ignoreMalformed);
+            this.script.setValidator(s -> {
+                if (s != null && indexed.get() == false && hasDocValues.get() == false) {
+                    throw new MapperParsingException("Cannot define script on field with index:false and doc_values:false");
+                }
+                if (s != null && multiFieldsBuilder.hasMultiFields()) {
+                    throw new MapperParsingException("Cannot define multifields on a field with a script");
+                }
+            });
         }
 
         @Override
@@ -100,6 +120,17 @@ private static ParsedGeoPoint parseNullValue(Object nullValue, boolean ignoreZVa
             return point;
         }
 
+        private FieldValues<ParsedGeoPoint> scriptValues() {
+            if (this.script.get() == null) {
+                return null;
+            }
+            GeoPointFieldScript.Factory factory = scriptCompiler.compile(this.script.get(), GeoPointFieldScript.CONTEXT);
+            return factory == null ? null : (lookup, ctx, doc, consumer) -> factory
+                .newFactory(name, script.get().getParams(), lookup)
+                .newInstance(ctx)
+                .runForDoc(v -> )
+        }
+
         @Override
         public FieldMapper build(ContentPath contentPath) {
             Parser<List<ParsedGeoPoint>> geoParser = new PointParser<>(name, ParsedGeoPoint::new, (parser, point) -> {
@@ -114,7 +145,8 @@ public FieldMapper build(ContentPath contentPath) {
 
     }
 
-    public static TypeParser PARSER = new TypeParser((n, c) -> new Builder(n, IGNORE_MALFORMED_SETTING.get(c.getSettings())));
+    public static TypeParser PARSER
+        = new TypeParser((n, c) -> new Builder(n, c.scriptCompiler(), IGNORE_MALFORMED_SETTING.get(c.getSettings())));
 
     private final Builder builder;
 
@@ -131,7 +163,7 @@ public GeoPointFieldMapper(String simpleName, MappedFieldType mappedFieldType,
 
     @Override
     public FieldMapper.Builder getMergeBuilder() {
-        return new Builder(simpleName(), builder.ignoreMalformed.getDefaultValue().value()).init(this);
+        return new Builder(simpleName(), builder.scriptCompiler, builder.ignoreMalformed.getDefaultValue().value()).init(this);
     }
 
     @Override
@@ -317,4 +349,9 @@ public List<IndexableField> indexShape(ParseContext context, List<? extends GeoP
             return fields;
         }
     }
+
+    @Override
+    protected void indexScriptValues(SearchLookup searchLookup, LeafReaderContext readerContext, int doc, ParseContext parseContext) {
+        super.indexScriptValues(searchLookup, readerContext, doc, parseContext);
+    }
 }
diff --git a/server/src/test/java/org/elasticsearch/index/mapper/GeoPointScriptMapperTests.java b/server/src/test/java/org/elasticsearch/index/mapper/GeoPointScriptMapperTests.java
new file mode 100644
index 0000000000000..3907e6b2eb5c4
--- /dev/null
+++ b/server/src/test/java/org/elasticsearch/index/mapper/GeoPointScriptMapperTests.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.index.mapper;
+
+import org.apache.lucene.index.IndexableField;
+import org.apache.lucene.index.LeafReaderContext;
+import org.elasticsearch.script.GeoPointFieldScript;
+import org.elasticsearch.search.lookup.SearchLookup;
+
+import java.util.Map;
+import java.util.function.Consumer;
+
+public class GeoPointScriptMapperTests extends MapperScriptTestCase<GeoPointFieldScript.Factory> {
+
+    private static GeoPointFieldScript.Factory factory(Consumer<GeoPointFieldScript> executor) {
+        return new GeoPointFieldScript.Factory() {
+            @Override
+            public GeoPointFieldScript.LeafFactory newFactory(String fieldName, Map<String, Object> params, SearchLookup searchLookup) {
+                return new GeoPointFieldScript.LeafFactory() {
+                    @Override
+                    public GeoPointFieldScript newInstance(LeafReaderContext ctx) {
+                        return new GeoPointFieldScript(fieldName, params, searchLookup, ctx) {
+                            @Override
+                            public void execute() {
+                                executor.accept(this);
+                            }
+                        };
+                    }
+                };
+            }
+        };
+    }
+
+    @Override
+    protected String type() {
+        return "geo_point";
+    }
+
+    @Override
+    protected GeoPointFieldScript.Factory serializableScript() {
+        return factory(s -> {});
+    }
+
+    @Override
+    protected GeoPointFieldScript.Factory errorThrowingScript() {
+        return factory(s -> {
+            throw new UnsupportedOperationException("Oops");
+        });
+    }
+
+    @Override
+    protected GeoPointFieldScript.Factory singleValueScript() {
+        return factory(s -> s.emit(1));
+    }
+
+    @Override
+    protected GeoPointFieldScript.Factory multipleValuesScript() {
+        return factory(s -> {
+            s.emit(1);
+            s.emit(2);
+        });
+    }
+
+    @Override
+    protected void assertMultipleValues(IndexableField[] fields) {
+        assertEquals(4, fields.length);
+        assertEquals("indexed,omitNorms,indexOptions=DOCS<field:F>", fields[0].toString());
+        assertEquals("docValuesType=SORTED_NUMERIC<field:0>", fields[1].toString());
+        assertEquals("indexed,omitNorms,indexOptions=DOCS<field:T>", fields[2].toString());
+        assertEquals("docValuesType=SORTED_NUMERIC<field:1>", fields[3].toString());
+    }
+
+    @Override
+    protected void assertDocValuesDisabled(IndexableField[] fields) {
+        assertEquals(1, fields.length);
+        assertEquals("indexed,omitNorms,indexOptions=DOCS<field:T>", fields[0].toString());
+    }
+
+    @Override
+    protected void assertIndexDisabled(IndexableField[] fields) {
+        assertEquals(1, fields.length);
+        assertEquals("docValuesType=SORTED_NUMERIC<field:1>", fields[0].toString());
+    }
+}

From ddb709f305efc00e972239522f203f933b8281dc Mon Sep 17 00:00:00 2001
From: Alan Woodward <romseygeek@apache.org>
Date: Mon, 19 Apr 2021 17:12:47 +0100
Subject: [PATCH 2/4] Add index-time scripts to geo_point field mapper

---
 .../103_geo_point_calculated_at_index.yml     | 206 ++++++++++++++++++
 .../mapper/AbstractGeometryFieldMapper.java   |   2 +-
 .../index/mapper/GeoPointFieldMapper.java     |  36 ++-
 .../script/GeoPointFieldScript.java           |   2 +-
 .../mapper/GeoPointFieldMapperTests.java      |  32 ++-
 5 files changed, 270 insertions(+), 8 deletions(-)
 create mode 100644 modules/runtime-fields-common/src/yamlRestTest/resources/rest-api-spec/test/runtime_fields/103_geo_point_calculated_at_index.yml

diff --git a/modules/runtime-fields-common/src/yamlRestTest/resources/rest-api-spec/test/runtime_fields/103_geo_point_calculated_at_index.yml b/modules/runtime-fields-common/src/yamlRestTest/resources/rest-api-spec/test/runtime_fields/103_geo_point_calculated_at_index.yml
new file mode 100644
index 0000000000000..d47c0200b9e25
--- /dev/null
+++ b/modules/runtime-fields-common/src/yamlRestTest/resources/rest-api-spec/test/runtime_fields/103_geo_point_calculated_at_index.yml
@@ -0,0 +1,206 @@
+---
+setup:
+  - do:
+      indices.create:
+        index: locations
+        body:
+          settings:
+            number_of_shards: 1
+            number_of_replicas: 0
+          mappings:
+            properties:
+              location_from_doc_value:
+                type: geo_point
+                script:
+                  source: |
+                    emit(doc["location"].lat, doc["location"].lon);
+              location_from_source:
+                type: geo_point
+                script:
+                  source: |
+                    emit(params._source.location.lat, params._source.location.lon);
+              timestamp:
+                type: date
+              location:
+                type: geo_point
+  - do:
+      bulk:
+        index: locations
+        refresh: true
+        body: |
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:30:17-05:00", "location" : {"lat": 13.5, "lon" : 34.89}}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:30:53-05:00", "location" : {"lat": -7.9, "lon" : 120.78}}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:31:12-05:00", "location" : {"lat": 45.78, "lon" : -173.45}}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:31:19-05:00", "location" : {"lat": 32.45, "lon" : 45.6}}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:31:22-05:00", "location" : {"lat": -63.24, "lon" : 31.0}}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:31:27-05:00", "location" : {"lat": 0.0, "lon" : 0.0}}
+
+
+---
+"get mapping":
+  - do:
+      indices.get_mapping:
+        index: locations
+  - match: {locations.mappings.properties.location_from_source.type: geo_point }
+  - match:
+      locations.mappings.properties.location_from_source.script.source: |
+        emit(params._source.location.lat, params._source.location.lon);
+  - match: {locations.mappings.properties.location_from_source.script.lang: painless }
+
+---
+"fetch fields from source":
+  - do:
+      search:
+        index: locations
+        body:
+          sort: timestamp
+          fields: [location, location_from_doc_value, location_from_source]
+  - match: {hits.total.value: 6}
+  - match: {hits.hits.0.fields.location.0.type: "Point" }
+  - match: {hits.hits.0.fields.location.0.coordinates: [34.89, 13.5] }
+  # calculated from scripts adds annoying extra precision
+  - match: { hits.hits.0.fields.location_from_doc_value.0.type: "Point" }
+  - match: { hits.hits.0.fields.location_from_doc_value.0.coordinates: [ 34.889999935403466, 13.499999991618097 ] }
+  - match: { hits.hits.0.fields.location_from_source.0.type: "Point" }
+  - match: { hits.hits.0.fields.location_from_source.0.coordinates: [ 34.889999935403466, 13.499999991618097 ] }
+
+---
+"exists query":
+  - do:
+      search:
+        index: locations
+        body:
+          query:
+            exists:
+              field: location_from_source
+  - match: {hits.total.value: 6}
+
+---
+"geo bounding box query":
+  - do:
+      search:
+        index: locations
+        body:
+          query:
+            geo_bounding_box:
+              location_from_source:
+                top_left:
+                  lat: 10
+                  lon: -10
+                bottom_right:
+                  lat: -10
+                  lon: 10
+  - match: {hits.total.value: 1}
+
+---
+"geo shape query":
+  - do:
+      search:
+        index: locations
+        body:
+          query:
+            geo_shape:
+              location_from_source:
+                shape:
+                  type: "envelope"
+                  coordinates: [ [ -10, 10 ], [ 10, -10 ] ]
+  - match: {hits.total.value: 1}
+
+---
+"geo distance query":
+  - do:
+      search:
+        index: locations
+        body:
+          query:
+            geo_distance:
+              distance: "2000km"
+              location_from_source:
+                lat: 0
+                lon: 0
+  - match: {hits.total.value: 1}
+
+---
+"bounds agg":
+  - do:
+      search:
+        index: locations
+        body:
+          aggs:
+            bounds:
+              geo_bounds:
+                field: "location"
+                wrap_longitude: false
+            bounds_from_doc_value:
+              geo_bounds:
+                field: "location_from_doc_value"
+                wrap_longitude: false
+            bounds_from_source:
+              geo_bounds:
+                field: "location_from_source"
+                wrap_longitude: false
+  - match: {hits.total.value: 6}
+  - match: {aggregations.bounds.bounds.top_left.lat: 45.7799999602139 }
+  - match: {aggregations.bounds.bounds.top_left.lon: -173.4500000718981 }
+  - match: {aggregations.bounds.bounds.bottom_right.lat: -63.240000014193356 }
+  - match: {aggregations.bounds.bounds.bottom_right.lon: 120.77999993227422 }
+  - match: {aggregations.bounds_from_doc_value.bounds.top_left.lat: 45.7799999602139 }
+  - match: {aggregations.bounds_from_doc_value.bounds.top_left.lon: -173.4500000718981 }
+  - match: {aggregations.bounds_from_doc_value.bounds.bottom_right.lat: -63.240000014193356 }
+  - match: {aggregations.bounds_from_doc_value.bounds.bottom_right.lon: 120.77999993227422 }
+  - match: {aggregations.bounds_from_source.bounds.top_left.lat: 45.7799999602139 }
+  - match: {aggregations.bounds_from_source.bounds.top_left.lon: -173.4500000718981 }
+  - match: {aggregations.bounds_from_source.bounds.bottom_right.lat: -63.240000014193356 }
+  - match: {aggregations.bounds_from_source.bounds.bottom_right.lon: 120.77999993227422 }
+
+---
+"geo_distance sort":
+  - do:
+      search:
+        index: locations
+        body:
+          sort:
+            _geo_distance:
+              location_from_source:
+                lat: 0.0
+                lon: 0.0
+  - match: {hits.total.value: 6}
+  - match: {hits.hits.0._source.location.lat: 0.0 }
+  - match: {hits.hits.0._source.location.lon: 0.0 }
+  - match: {hits.hits.1._source.location.lat: 13.5 }
+  - match: {hits.hits.1._source.location.lon: 34.89 }
+  - match: {hits.hits.2._source.location.lat: 32.45 }
+  - match: {hits.hits.2._source.location.lon: 45.6 }
+  - match: {hits.hits.3._source.location.lat: -63.24 }
+  - match: {hits.hits.3._source.location.lon: 31.0 }
+
+---
+"distance_feature query":
+  - do:
+      search:
+        index: locations
+        body:
+          query:
+            bool:
+              should:
+                distance_feature:
+                  field: "location"
+                  pivot: "1000km"
+                  origin: [0.0, 0.0]
+
+  - match: {hits.total.value: 6}
+  - match: {hits.hits.0._source.location.lat: 0.0 }
+  - match: {hits.hits.0._source.location.lon: 0.0 }
+  - match: {hits.hits.1._source.location.lat: 13.5 }
+  - match: {hits.hits.1._source.location.lon: 34.89 }
+  - match: {hits.hits.2._source.location.lat: 32.45 }
+  - match: {hits.hits.2._source.location.lon: 45.6 }
+  - match: {hits.hits.3._source.location.lat: -63.24 }
+  - match: {hits.hits.3._source.location.lon: 31.0 }
+
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/AbstractGeometryFieldMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/AbstractGeometryFieldMapper.java
index 8a688f18321c4..160e29f002ced 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/AbstractGeometryFieldMapper.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/AbstractGeometryFieldMapper.java
@@ -89,7 +89,7 @@ public final Query termQuery(Object value, SearchExecutionContext context) {
         }
 
         @Override
-        public final ValueFetcher valueFetcher(SearchExecutionContext context, String format) {
+        public ValueFetcher valueFetcher(SearchExecutionContext context, String format) {
             String geoFormat = format != null ? format : GeoJsonGeometryFormat.NAME;
 
             if (parsesArrayValue) {
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/GeoPointFieldMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/GeoPointFieldMapper.java
index 0f089a0c7f610..e5d8484e8eace 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/GeoPointFieldMapper.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/GeoPointFieldMapper.java
@@ -17,9 +17,12 @@
 import org.apache.lucene.search.Query;
 import org.elasticsearch.ElasticsearchParseException;
 import org.elasticsearch.common.Explicit;
+import org.elasticsearch.common.geo.GeoJsonGeometryFormat;
 import org.elasticsearch.common.geo.GeoPoint;
 import org.elasticsearch.common.geo.GeoShapeUtils;
 import org.elasticsearch.common.geo.GeoUtils;
+import org.elasticsearch.common.geo.GeometryFormat;
+import org.elasticsearch.common.geo.GeometryParser;
 import org.elasticsearch.common.geo.ShapeRelation;
 import org.elasticsearch.common.unit.DistanceUnit;
 import org.elasticsearch.geometry.Geometry;
@@ -119,7 +122,7 @@ private FieldValues<GeoPoint> scriptValues() {
             return factory == null ? null : (lookup, ctx, doc, consumer) -> factory
                 .newFactory(name, script.get().getParams(), lookup)
                 .newInstance(ctx)
-                .runForDoc(doc, consumer);
+                .runGeoPointForDoc(doc, consumer);
         }
 
         @Override
@@ -134,8 +137,14 @@ public FieldMapper build(ContentPath contentPath) {
                 (ParsedGeoPoint) nullValue.get(),
                 ignoreZValue.get().value(),
                 ignoreMalformed.get().value());
-            GeoPointFieldType ft
-                = new GeoPointFieldType(buildFullName(contentPath), indexed.get(), stored.get(), hasDocValues.get(), geoParser, meta.get());
+            GeoPointFieldType ft = new GeoPointFieldType(
+                buildFullName(contentPath),
+                indexed.get(),
+                stored.get(),
+                hasDocValues.get(),
+                geoParser,
+                scriptValues(),
+                meta.get());
             if (this.script.get() == null) {
                 return new GeoPointFieldMapper(name, ft, multiFieldsBuilder.build(this, contentPath),
                     copyTo.build(), geoParser, this);
@@ -209,13 +218,17 @@ protected String contentType() {
 
     public static class GeoPointFieldType extends AbstractGeometryFieldType implements GeoShapeQueryable {
 
+        private static final GeometryParser PARSER = new GeometryParser(true, true, true);
+        private final FieldValues<GeoPoint> scriptValues;
+
         private GeoPointFieldType(String name, boolean indexed, boolean stored, boolean hasDocValues,
-                                  Parser<?> parser, Map<String, String> meta) {
+                                  Parser<ParsedGeoPoint> parser, FieldValues<GeoPoint> scriptValues, Map<String, String> meta) {
             super(name, indexed, stored, hasDocValues, true, parser, meta);
+            this.scriptValues = scriptValues;
         }
 
         public GeoPointFieldType(String name) {
-            this(name, true, false, true, null, Collections.emptyMap());
+            this(name, true, false, true, null, null, Collections.emptyMap());
         }
 
         @Override
@@ -223,6 +236,19 @@ public String typeName() {
             return CONTENT_TYPE;
         }
 
+        @Override
+        public ValueFetcher valueFetcher(SearchExecutionContext context, String format) {
+            if (scriptValues == null) {
+                return super.valueFetcher(context, format);
+            }
+            String geoFormat = format != null ? format : GeoJsonGeometryFormat.NAME;
+            GeometryFormat<Geometry> geometryFormat = PARSER.geometryFormat(geoFormat);
+            return FieldValues.valueFetcher(scriptValues, v -> {
+                GeoPoint p = (GeoPoint) v;
+                return geometryFormat.toXContentAsObject(new Point(p.lon(), p.lat()));
+            }, context);
+        }
+
         @Override
         public Query geoShapeQuery(Geometry shape, String fieldName, ShapeRelation relation, SearchExecutionContext context) {
             final LatLonGeometry[] luceneGeometries = GeoShapeUtils.toLuceneGeometry(fieldName, context, shape, relation);
diff --git a/server/src/main/java/org/elasticsearch/script/GeoPointFieldScript.java b/server/src/main/java/org/elasticsearch/script/GeoPointFieldScript.java
index 330728b76e6c6..853193899eb5a 100644
--- a/server/src/main/java/org/elasticsearch/script/GeoPointFieldScript.java
+++ b/server/src/main/java/org/elasticsearch/script/GeoPointFieldScript.java
@@ -42,7 +42,7 @@ public GeoPointFieldScript(String fieldName, Map<String, Object> params, SearchL
         super(fieldName, params, searchLookup, ctx);
     }
 
-    public void runForDoc(int doc, Consumer<GeoPoint> consumer) {
+    public void runGeoPointForDoc(int doc, Consumer<GeoPoint> consumer) {
         runForDoc(doc);
         GeoPoint point = new GeoPoint();
         for (int i = 0; i < count(); i++) {
diff --git a/server/src/test/java/org/elasticsearch/index/mapper/GeoPointFieldMapperTests.java b/server/src/test/java/org/elasticsearch/index/mapper/GeoPointFieldMapperTests.java
index caf4d10d6f90e..a574b57a9e89f 100644
--- a/server/src/test/java/org/elasticsearch/index/mapper/GeoPointFieldMapperTests.java
+++ b/server/src/test/java/org/elasticsearch/index/mapper/GeoPointFieldMapperTests.java
@@ -313,7 +313,7 @@ public void testInvalidGeohashNotIgnored() throws Exception {
             MapperParsingException.class,
             () -> mapper.parse(source(b -> b.field("field", "1234.333")))
         );
-        assertThat(e.getMessage(), containsString("Failed to parse field [field] of type [geo_point]"));
+        assertThat(e.getMessage(), containsString("failed to parse field [field] of type [geo_point]"));
         assertThat(e.getRootCause().getMessage(), containsString("unsupported symbol [.] in geohash [1234.333]"));
     }
 
@@ -361,4 +361,34 @@ protected Object generateRandomInputValue(MappedFieldType ft) {
         assumeFalse("Test implemented in a follow up", true);
         return null;
     }
+
+    public void testScriptAndPrecludedParameters() {
+        {
+            Exception e = expectThrows(MapperParsingException.class, () -> createDocumentMapper(fieldMapping(b -> {
+                b.field("type", "geo_point");
+                b.field("script", "test");
+                b.field("ignore_z_value", "true");
+            })));
+            assertThat(e.getMessage(),
+                equalTo("Failed to parse mapping: Field [ignore_z_value] cannot be set in conjunction with field [script]"));
+        }
+        {
+            Exception e = expectThrows(MapperParsingException.class, () -> createDocumentMapper(fieldMapping(b -> {
+                b.field("type", "geo_point");
+                b.field("script", "test");
+                b.field("null_value", "POINT (1 1)");
+            })));
+            assertThat(e.getMessage(),
+                equalTo("Failed to parse mapping: Field [null_value] cannot be set in conjunction with field [script]"));
+        }
+        {
+            Exception e = expectThrows(MapperParsingException.class, () -> createDocumentMapper(fieldMapping(b -> {
+                b.field("type", "long");
+                b.field("script", "test");
+                b.field("ignore_malformed", "true");
+            })));
+            assertThat(e.getMessage(),
+                equalTo("Failed to parse mapping: Field [ignore_malformed] cannot be set in conjunction with field [script]"));
+        }
+    }
 }

From 00a1d1ac554f72e6e44fa3a1e83b8af663eb6faa Mon Sep 17 00:00:00 2001
From: Alan Woodward <romseygeek@apache.org>
Date: Mon, 19 Apr 2021 17:49:53 +0100
Subject: [PATCH 3/4] tests

---
 .../xpack/spatial/index/mapper/CartesianFieldMapperTests.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/x-pack/plugin/spatial/src/test/java/org/elasticsearch/xpack/spatial/index/mapper/CartesianFieldMapperTests.java b/x-pack/plugin/spatial/src/test/java/org/elasticsearch/xpack/spatial/index/mapper/CartesianFieldMapperTests.java
index f986125ba954e..4ee7988e564f4 100644
--- a/x-pack/plugin/spatial/src/test/java/org/elasticsearch/xpack/spatial/index/mapper/CartesianFieldMapperTests.java
+++ b/x-pack/plugin/spatial/src/test/java/org/elasticsearch/xpack/spatial/index/mapper/CartesianFieldMapperTests.java
@@ -145,7 +145,7 @@ public void testZValue() throws IOException {
         MapperParsingException e = expectThrows(MapperParsingException.class,
             () -> mapper2.parse(source(b -> b.field(FIELD_NAME, "POINT (2000.1 305.6 34567.33)")))
         );
-        assertThat(e.getMessage(), containsString("Failed to parse field [" + FIELD_NAME + "] of type"));
+        assertThat(e.getMessage(), containsString("failed to parse field [" + FIELD_NAME + "] of type"));
         assertThat(e.getRootCause().getMessage(),
             containsString("found Z value [34567.33] but [ignore_z_value] parameter is [false]"));
     }

From 8d65c25d7b22e758afbec28829567a81a9b6ebc4 Mon Sep 17 00:00:00 2001
From: Alan Woodward <romseygeek@apache.org>
Date: Tue, 20 Apr 2021 09:05:13 +0100
Subject: [PATCH 4/4] docs

---
 .../mapping/types/geo-point.asciidoc          | 29 +++++++++++++++++--
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/docs/reference/mapping/types/geo-point.asciidoc b/docs/reference/mapping/types/geo-point.asciidoc
index 3d5f76a28528f..03d9c731d93b8 100644
--- a/docs/reference/mapping/types/geo-point.asciidoc
+++ b/docs/reference/mapping/types/geo-point.asciidoc
@@ -123,20 +123,43 @@ The following parameters are accepted by `geo_point` fields:
 
     If `true`, malformed geo-points are ignored. If `false` (default),
     malformed geo-points throw an exception and reject the whole document.
-    A geo-point is considered malformed if its latitude is outside the range 
+    A geo-point is considered malformed if its latitude is outside the range
     -90 <= latitude <= 90, or if its longitude is outside the range -180 <= longitude <= 180.
+    Note that this cannot be set if the `script` parameter is used.
 
 `ignore_z_value`::
 
     If `true` (default) three dimension points will be accepted (stored in source)
     but only latitude and longitude values will be indexed; the third dimension is
     ignored. If `false`, geo-points containing any more than latitude and longitude
-    (two dimensions) values throw an exception and reject the whole document.
+    (two dimensions) values throw an exception and reject the whole document. Note
+    that this cannot be set if the `script` parameter is used.
 
 <<null-value,`null_value`>>::
 
     Accepts an geopoint value which is substituted for any explicit `null` values.
-    Defaults to `null`, which means the field is treated as missing.
+    Defaults to `null`, which means the field is treated as missing. Note that this
+    cannot be set if the `script` parameter is used.
+
+`on_script_error`::
+
+    Defines what to do if the script defined by the `script` parameter
+    throws an error at indexing time. Accepts `fail` (default), which
+    will cause the entire document to be rejected, and `continue`, which
+    will register the field in the document's
+    <<mapping-ignored-field,`_ignored`>> metadata field and continue
+    indexing. This parameter can only be set if the `script` field is
+    also set.
+
+`script`::
+
+    If this parameter is set, then the field will index values generated
+    by this script, rather than reading the values directly from the
+    source. If a value is set for this field on the input document, then
+    the document will be rejected with an error.
+    Scripts are in the same format as their
+    <<runtime-mapping-fields,runtime equivalent>>, and should emit points
+    as a pair of (lat, lon) double values.
 
 ==== Using geo-points in scripts