embulk-filter-column 0.4.0 → 0.5.0.pre1

data/src/main/java/org/embulk/filter/column/ColumnVisitorImpl.java

@@ -0,0 +1,275 @@
+package org.embulk.filter.column;
+
+import com.google.common.base.Throwables;
+
+import org.embulk.filter.column.ColumnFilterPlugin.ColumnConfig;
+import org.embulk.filter.column.ColumnFilterPlugin.PluginTask;
+
+import org.embulk.spi.Column;
+import org.embulk.spi.ColumnVisitor;
+import org.embulk.spi.Exec;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.PageReader;
+import org.embulk.spi.Schema;
+import org.embulk.spi.SchemaConfigException;
+import org.embulk.spi.json.JsonParser;
+import org.embulk.spi.time.Timestamp;
+import org.embulk.spi.time.TimestampParseException;
+import org.embulk.spi.time.TimestampParser;
+import org.embulk.spi.type.BooleanType;
+import org.embulk.spi.type.DoubleType;
+import org.embulk.spi.type.JsonType;
+import org.embulk.spi.type.LongType;
+import org.embulk.spi.type.StringType;
+import org.embulk.spi.type.TimestampType;
+import org.embulk.spi.type.Type;
+
+import org.joda.time.DateTimeZone;
+import org.msgpack.value.Value;
+import org.slf4j.Logger;
+
+import java.util.HashMap;
+import java.util.List;
+
+public class ColumnVisitorImpl implements ColumnVisitor
+{
+    private static final Logger logger = Exec.getLogger(ColumnFilterPlugin.class);
+    private final PluginTask task;
+    private final Schema inputSchema;
+    private final Schema outputSchema;
+    private final PageReader pageReader;
+    private final PageBuilder pageBuilder;
+    private final HashMap<Column, Column> outputInputColumnMap = new HashMap<>();
+    private final HashMap<Column, Object> outputDefaultMap = new HashMap<>();
+    private final JsonVisitor jsonVisitor;
+
+    ColumnVisitorImpl(PluginTask task, Schema inputSchema, Schema outputSchema, PageReader pageReader, PageBuilder pageBuilder)
+    {
+        this.task = task;
+        this.inputSchema = inputSchema;
+        this.outputSchema = outputSchema;
+        this.pageReader = pageReader;
+        this.pageBuilder = pageBuilder;
+        buildOutputInputColumnMap();
+        buildOutputDefaultMap();
+        this.jsonVisitor = new JsonVisitor(task, inputSchema, outputSchema);
+    }
+
+    // Map outputColumn => inputColumn
+    private void buildOutputInputColumnMap()
+    {
+        for (Column outputColumn : outputSchema.getColumns()) {
+            String name    = outputColumn.getName();
+            String srcName = getSrc(name, task.getColumns());
+            if (srcName == null) {
+                srcName = getSrc(name, task.getAddColumns());
+            }
+            if (srcName == null) {
+                srcName = name;
+            }
+            Column inputColumn;
+            try {
+                inputColumn = inputSchema.lookupColumn(srcName);
+            }
+            catch (SchemaConfigException ex) {
+                inputColumn = null;
+            }
+            outputInputColumnMap.put(outputColumn, inputColumn); // NOTE: inputColumn would be null
+        }
+    }
+
+    // Map outputColumn => default value if present
+    private void buildOutputDefaultMap()
+    {
+        for (Column outputColumn : outputSchema.getColumns()) {
+            String name = outputColumn.getName();
+            Type type = outputColumn.getType();
+
+            Object defaultValue = getDefault(task, name, type, task.getColumns());
+            if (defaultValue == null) {
+                defaultValue = getDefault(task, name, type, task.getAddColumns());
+            }
+            if (defaultValue != null) {
+                outputDefaultMap.put(outputColumn, defaultValue);
+            }
+        }
+    }
+
+    static String getSrc(String name, List<ColumnConfig> columnConfigs)
+    {
+        for (ColumnConfig columnConfig : columnConfigs) {
+            if (columnConfig.getName().equals(name) &&
+                    columnConfig.getSrc().isPresent()) {
+                return columnConfig.getSrc().get();
+            }
+        }
+        return null;
+    }
+
+    static Object getDefault(PluginTask task, String name, Type type, List<ColumnConfig> columnConfigs)
+    {
+        for (ColumnConfig columnConfig : columnConfigs) {
+            if (columnConfig.getName().equals(name)) {
+                return getDefault(task, name, type, columnConfig);
+            }
+        }
+        return null;
+    }
+
+    static Object getDefault(PluginTask task, String name, Type type, ColumnConfig columnConfig)
+    {
+        if (type instanceof BooleanType) {
+            if (columnConfig.getDefault().isPresent()) {
+                return (Boolean) columnConfig.getDefault().get();
+            }
+        }
+        else if (type instanceof LongType) {
+            if (columnConfig.getDefault().isPresent()) {
+                return new Long(columnConfig.getDefault().get().toString());
+            }
+        }
+        else if (type instanceof DoubleType) {
+            if (columnConfig.getDefault().isPresent()) {
+                return new Double(columnConfig.getDefault().get().toString());
+            }
+        }
+        else if (type instanceof StringType) {
+            if (columnConfig.getDefault().isPresent()) {
+                return columnConfig.getDefault().get();
+            }
+        }
+        else if (type instanceof JsonType) {
+            if (columnConfig.getDefault().isPresent()) {
+                JsonParser parser = new JsonParser();
+                return parser.parse((String) columnConfig.getDefault().get());
+            }
+        }
+        else if (type instanceof TimestampType) {
+            if (columnConfig.getDefault().isPresent()) {
+                String time   = (String) columnConfig.getDefault().get();
+                String format = columnConfig.getFormat().or(task.getDefaultTimestampFormat());
+                DateTimeZone timezone = columnConfig.getTimeZone().or(task.getDefaultTimeZone());
+                TimestampParser parser = new TimestampParser(task.getJRuby(), format, timezone);
+                try {
+                    Timestamp defaultValue = parser.parse(time);
+                    return defaultValue;
+                }
+                catch (TimestampParseException ex) {
+                    throw Throwables.propagate(ex);
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public void booleanColumn(Column outputColumn)
+    {
+        Column inputColumn = outputInputColumnMap.get(outputColumn);
+        if (inputColumn == null || pageReader.isNull(inputColumn)) {
+            Boolean defaultValue = (Boolean) outputDefaultMap.get(outputColumn);
+            if (defaultValue == null) {
+                pageBuilder.setNull(outputColumn);
+            }
+            else {
+                pageBuilder.setBoolean(outputColumn, defaultValue.booleanValue());
+            }
+        }
+        else {
+            pageBuilder.setBoolean(outputColumn, pageReader.getBoolean(inputColumn));
+        }
+    }
+
+    @Override
+    public void longColumn(Column outputColumn)
+    {
+        Column inputColumn = outputInputColumnMap.get(outputColumn);
+        if (inputColumn == null || pageReader.isNull(inputColumn)) {
+            Long defaultValue = (Long) outputDefaultMap.get(outputColumn);
+            if (defaultValue == null) {
+                pageBuilder.setNull(outputColumn);
+            }
+            else {
+                pageBuilder.setLong(outputColumn, defaultValue.longValue());
+            }
+        }
+        else {
+            pageBuilder.setLong(outputColumn, pageReader.getLong(inputColumn));
+        }
+    }
+
+    @Override
+    public void doubleColumn(Column outputColumn)
+    {
+        Column inputColumn = outputInputColumnMap.get(outputColumn);
+        if (inputColumn == null || pageReader.isNull(inputColumn)) {
+            Double defaultValue = (Double) outputDefaultMap.get(outputColumn);
+            if (defaultValue == null) {
+                pageBuilder.setNull(outputColumn);
+            }
+            else {
+                pageBuilder.setDouble(outputColumn, defaultValue.doubleValue());
+            }
+        }
+        else {
+            pageBuilder.setDouble(outputColumn, pageReader.getDouble(inputColumn));
+        }
+    }
+
+    @Override
+    public void stringColumn(Column outputColumn)
+    {
+        Column inputColumn = outputInputColumnMap.get(outputColumn);
+        if (inputColumn == null || pageReader.isNull(inputColumn)) {
+            String defaultValue = (String) outputDefaultMap.get(outputColumn);
+            if (defaultValue == null) {
+                pageBuilder.setNull(outputColumn);
+            }
+            else {
+                pageBuilder.setString(outputColumn, defaultValue);
+            }
+        }
+        else {
+            pageBuilder.setString(outputColumn, pageReader.getString(inputColumn));
+        }
+    }
+
+    @Override
+    public void jsonColumn(Column outputColumn)
+    {
+        Column inputColumn = outputInputColumnMap.get(outputColumn);
+        if (inputColumn == null || pageReader.isNull(inputColumn)) {
+            Value defaultValue = (Value) outputDefaultMap.get(outputColumn);
+            if (defaultValue == null) {
+                pageBuilder.setNull(outputColumn);
+            }
+            else {
+                String jsonPath = new StringBuilder("$.").append(inputColumn.getName()).toString();
+                pageBuilder.setJson(outputColumn, jsonVisitor.visit(jsonPath, defaultValue));
+            }
+        }
+        else {
+            Value value = pageReader.getJson(inputColumn);
+            String jsonPath = new StringBuilder("$.").append(inputColumn.getName()).toString();
+            pageBuilder.setJson(outputColumn, jsonVisitor.visit(jsonPath, value));
+        }
+    }
+
+    @Override
+    public void timestampColumn(Column outputColumn)
+    {
+        Column inputColumn = outputInputColumnMap.get(outputColumn);
+        if (inputColumn == null || pageReader.isNull(inputColumn)) {
+            Timestamp defaultValue = (Timestamp) outputDefaultMap.get(outputColumn);
+            if (defaultValue == null) {
+                pageBuilder.setNull(outputColumn);
+            }
+            else {
+                pageBuilder.setTimestamp(outputColumn, defaultValue);
+            }
+        }
+        else {
+            pageBuilder.setTimestamp(outputColumn, pageReader.getTimestamp(inputColumn));
+        }
+    }
+}

data/src/main/java/org/embulk/filter/column/JsonColumn.java

@@ -0,0 +1,104 @@
+package org.embulk.filter.column;
+
+import org.embulk.spi.type.Type;
+import org.msgpack.value.StringValue;
+import org.msgpack.value.Value;
+import org.msgpack.value.ValueFactory;
+
+public class JsonColumn
+{
+    private final String name;
+    private final Type type;
+    private final Value defaultValue;
+    private String objectPath = null; // object path (like directory) of json path
+    private String elementPath = null; // element path (like leaf) of json path
+    private StringValue nameValue = null;
+    private StringValue objectPathValue = null;
+    private StringValue elementPathValue = null;
+
+    public JsonColumn(
+            String name,
+            Type type)
+    {
+        this(name, type, null);
+    }
+
+    public JsonColumn(
+            String name,
+            Type type,
+            Value defaultValue)
+    {
+        this.name = name;
+        this.type = type;
+        this.defaultValue = (defaultValue == null ? ValueFactory.newNil() : defaultValue);
+        this.objectPath = objectPath(name);
+        this.elementPath = elementPath(name);
+        this.nameValue = ValueFactory.newString(name);
+        this.objectPathValue = ValueFactory.newString(objectPath);
+        this.elementPathValue = ValueFactory.newString(elementPath);
+    }
+
+    public String getName()
+    {
+        return name;
+    }
+
+    public Type getType()
+    {
+        return type;
+    }
+
+    public Value getDefaultValue()
+    {
+        return defaultValue;
+    }
+
+    public String getObjectPath()
+    {
+        return objectPath;
+    }
+
+    public String getElementPath()
+    {
+        return elementPath;
+    }
+
+    public StringValue getNameValue()
+    {
+        return nameValue;
+    }
+
+    public StringValue getObjectPathValue()
+    {
+        return objectPathValue;
+    }
+
+    public StringValue getElementPathValue()
+    {
+        return elementPathValue;
+    }
+
+    public static String objectPath(String path)
+    {
+        String[] parts = path.split("\\.");
+        StringBuilder builder = new StringBuilder();
+        builder.append(parts[0]);
+        for (int i = 1; i < parts.length - 1; i++) {
+            builder.append(".").append(parts[i]);
+        }
+        if (parts[parts.length - 1].contains("[")) {
+            String[] arrayParts = parts[parts.length - 1].split("\\[");
+            builder.append(".").append(arrayParts[0]);
+            for (int j = 1; j < arrayParts.length - 1; j++) {
+                builder.append("[").append(arrayParts[j]);
+            }
+        }
+        return builder.toString();
+    }
+
+    public static String elementPath(String path)
+    {
+        String[] parts = path.split("\\.");
+        return parts[parts.length - 1];
+    }
+}

data/src/main/java/org/embulk/filter/column/JsonVisitor.java

@@ -0,0 +1,328 @@
+package org.embulk.filter.column;
+
+import org.embulk.config.ConfigException;
+import org.embulk.filter.column.ColumnFilterPlugin.ColumnConfig;
+import org.embulk.filter.column.ColumnFilterPlugin.PluginTask;
+
+import org.embulk.spi.Exec;
+import org.embulk.spi.Schema;
+import org.embulk.spi.SchemaConfigException;
+import org.embulk.spi.type.BooleanType;
+import org.embulk.spi.type.DoubleType;
+import org.embulk.spi.type.JsonType;
+import org.embulk.spi.type.LongType;
+import org.embulk.spi.type.StringType;
+import org.embulk.spi.type.TimestampType;
+import org.embulk.spi.type.Type;
+import org.msgpack.value.ArrayValue;
+import org.msgpack.value.MapValue;
+import org.msgpack.value.Value;
+import org.msgpack.value.ValueFactory;
+
+import org.slf4j.Logger;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class JsonVisitor
+{
+    private static final Logger logger = Exec.getLogger(ColumnFilterPlugin.class);
+    private final PluginTask task;
+    private final Schema inputSchema;
+    private final Schema outputSchema;
+    private final HashSet<String> shouldVisitSet = new HashSet<>();
+    private final HashMap<String, LinkedHashMap<String, JsonColumn>> jsonColumns = new HashMap<>();
+    private final HashMap<String, LinkedHashMap<String, JsonColumn>> jsonAddColumns = new HashMap<>();
+    private final HashMap<String, HashSet<String>> jsonDropColumns = new HashMap<>();
+
+    JsonVisitor(PluginTask task, Schema inputSchema, Schema outputSchema)
+    {
+        this.task         = task;
+        this.inputSchema  = inputSchema;
+        this.outputSchema = outputSchema;
+
+        buildShouldVisitSet();
+        buildJsonSchema();
+    }
+
+    static Value getDefault(PluginTask task, String name, Type type, ColumnConfig columnConfig)
+    {
+        Object defaultValue = ColumnVisitorImpl.getDefault(task, name, type, columnConfig);
+        if (defaultValue == null) {
+            return ValueFactory.newNil();
+        }
+        if (type instanceof BooleanType) {
+            return ValueFactory.newBoolean((Boolean) defaultValue);
+        }
+        else if (type instanceof LongType) {
+            return ValueFactory.newInteger((Long) defaultValue);
+        }
+        else if (type instanceof DoubleType) {
+            return ValueFactory.newFloat((Double) defaultValue);
+        }
+        else if (type instanceof StringType) {
+            return ValueFactory.newString((String) defaultValue.toString());
+        }
+        else if (type instanceof JsonType) {
+            return (Value) defaultValue;
+        }
+        else if (type instanceof TimestampType) {
+            throw new ConfigException("type: timestamp is not available in json path");
+        }
+        else {
+            throw new ConfigException(String.format("type: '%s' is not supported", type));
+        }
+    }
+
+    private void jsonColumnsPut(String path, JsonColumn value)
+    {
+        String objectPath = JsonColumn.objectPath(path);
+        if (! jsonColumns.containsKey(objectPath)) {
+            jsonColumns.put(objectPath, new LinkedHashMap<String, JsonColumn>());
+        }
+        jsonColumns.get(objectPath).put(path, value);
+    }
+
+    private void jsonAddColumnsPut(String path, JsonColumn value)
+    {
+        String objectPath = JsonColumn.objectPath(path);
+        if (! jsonAddColumns.containsKey(objectPath)) {
+            jsonAddColumns.put(objectPath, new LinkedHashMap<String, JsonColumn>());
+        }
+        jsonAddColumns.get(objectPath).put(path, value);
+    }
+
+    private void jsonDropColumnsPut(String path)
+    {
+        String objectPath = JsonColumn.objectPath(path);
+        if (! jsonDropColumns.containsKey(objectPath)) {
+            jsonDropColumns.put(objectPath, new HashSet<String>());
+        }
+        jsonDropColumns.get(objectPath).add(path);
+    }
+
+    // build jsonColumns, jsonAddColumns, and jsonDropColumns
+    private void buildJsonSchema()
+    {
+        List<ColumnConfig> columns = task.getColumns();
+        List<ColumnConfig> addColumns = task.getAddColumns();
+        List<ColumnConfig> dropColumns = task.getDropColumns();
+
+        int i = 0;
+        if (dropColumns.size() > 0) {
+            for (ColumnConfig dropColumn : dropColumns) {
+                String name = dropColumn.getName();
+                // skip NON json path notation to build output schema
+                if (! name.startsWith("$.")) {
+                    continue;
+                }
+                jsonDropColumnsPut(name);
+            }
+        }
+        else if (columns.size() > 0) {
+            for (ColumnConfig column : columns) {
+                String name = column.getName();
+                // skip NON json path notation to build output schema
+                if (! name.startsWith("$.")) {
+                    continue;
+                }
+                if (column.getSrc().isPresent()) {
+                    throw new ConfigException(String.format("columns: src is not supported for json path yet: '%s'", name));
+                }
+                else if (column.getType().isPresent() && column.getDefault().isPresent()) { // add column
+                    Type type = column.getType().get();
+                    Value defaultValue = getDefault(task, name, type, column);
+                    jsonColumnsPut(name, new JsonColumn(name, type, defaultValue));
+                }
+                else {
+                    Type type = column.getType().isPresent() ? column.getType().get() : null;
+                    jsonColumnsPut(name, new JsonColumn(name, type));
+                }
+            }
+        }
+
+        // Add columns to last. If you want to add to head or middle, you can use `columns` option
+        if (addColumns.size() > 0) {
+            for (ColumnConfig column : addColumns) {
+                String name = column.getName();
+                // skip NON json path notation to build output schema
+                if (! name.startsWith("$.")) {
+                    continue;
+                }
+                if (column.getSrc().isPresent()) {
+                    throw new ConfigException(String.format("add_columns: src is not supported for json path yet: '%s'", name));
+                }
+                else if (column.getType().isPresent() && column.getDefault().isPresent()) { // add column
+                    Type type = column.getType().get();
+                    Value defaultValue = getDefault(task, name, type, column);
+                    jsonAddColumnsPut(name, new JsonColumn(name, type, defaultValue));
+                }
+                else {
+                    throw new SchemaConfigException(String.format("add_columns: Column '%s' does not have \"type\" and \"default\"", name));
+                }
+            }
+        }
+    }
+
+    // json partial path => Boolean to avoid unnecessary type: json visit
+    private void buildShouldVisitSet()
+    {
+        ArrayList<ColumnConfig> columnConfigs = new ArrayList<>(task.getColumns());
+        columnConfigs.addAll(task.getAddColumns());
+        columnConfigs.addAll(task.getDropColumns());
+
+        for (ColumnConfig columnConfig : columnConfigs) {
+            String name = columnConfig.getName();
+            if (!name.startsWith("$.")) {
+                continue;
+            }
+            String[] parts = name.split("\\.");
+            StringBuilder partialPath = new StringBuilder("$");
+            for (int i = 1; i < parts.length; i++) {
+                if (parts[i].contains("[")) {
+                    String[] arrayParts = parts[i].split("\\[");
+                    partialPath.append(".").append(arrayParts[0]);
+                    this.shouldVisitSet.add(partialPath.toString());
+                    for (int j = 1; j < arrayParts.length; j++) {
+                        // Supports both [0] and [*]
+                        partialPath.append("[").append(arrayParts[j]);
+                        this.shouldVisitSet.add(partialPath.toString());
+                    }
+                }
+                else {
+                    partialPath.append(".").append(parts[i]);
+                    this.shouldVisitSet.add(partialPath.toString());
+                }
+            }
+        }
+    }
+
+    boolean shouldVisit(String jsonPath)
+    {
+        return shouldVisitSet.contains(jsonPath);
+    }
+
+    String newArrayJsonPath(String rootPath, int i)
+    {
+        String newPath = new StringBuilder(rootPath).append("[").append(Integer.toString(i)).append("]").toString();
+        if (! shouldVisit(newPath)) {
+            newPath = new StringBuilder(rootPath).append("[*]").toString(); // try [*] too
+        }
+        return newPath;
+    }
+
+    String newMapJsonPath(String rootPath, Value elementPathValue)
+    {
+        String elementPath = elementPathValue.asStringValue().asString();
+        String newPath = new StringBuilder(rootPath).append(".").append(elementPath).toString();
+        return newPath;
+    }
+
+    Value visitArray(String rootPath, ArrayValue arrayValue)
+    {
+        int size = arrayValue.size();
+        ArrayList<Value> newValue = new ArrayList<>(size);
+        int j = 0;
+        if (this.jsonDropColumns.containsKey(rootPath)) {
+            HashSet<String> jsonDropColumns = this.jsonDropColumns.get(rootPath);
+            for (int i = 0; i < size; i++) {
+                String newPath = newArrayJsonPath(rootPath, i);
+                if (! jsonDropColumns.contains(newPath)) {
+                    newValue.add(j++, visit(newPath, arrayValue.get(i)));
+                }
+            }
+        }
+        else if (this.jsonColumns.containsKey(rootPath)) {
+            LinkedHashMap<String, JsonColumn> jsonColumns = this.jsonColumns.get(rootPath);
+            for (int i = 0; i < size; i++) {
+                String newPath = newArrayJsonPath(rootPath, i);
+                if (jsonColumns.containsKey(newPath)) {
+                    newValue.add(j++, visit(newPath, arrayValue.get(i)));
+                }
+            }
+        }
+        else {
+            for (int i = 0; i < size; i++) {
+                String newPath = newArrayJsonPath(rootPath, i);
+                newValue.add(j++, visit(newPath, arrayValue.get(i)));
+            }
+        }
+        if (this.jsonAddColumns.containsKey(rootPath)) {
+            for (JsonColumn jsonColumn : this.jsonAddColumns.get(rootPath).values()) {
+                newValue.add(j++, jsonColumn.getDefaultValue());
+            }
+        }
+        return ValueFactory.newArray(newValue.toArray(new Value[0]), true);
+    }
+
+    Value visitMap(String rootPath, MapValue mapValue)
+    {
+        int size = mapValue.size();
+        int i = 0;
+        ArrayList<Value> newValue = new ArrayList<>(size * 2);
+        if (this.jsonDropColumns.containsKey(rootPath)) {
+            HashSet<String> jsonDropColumns = this.jsonDropColumns.get(rootPath);
+            for (Map.Entry<Value, Value> entry : mapValue.entrySet()) {
+                Value k = entry.getKey();
+                Value v = entry.getValue();
+                String newPath = newMapJsonPath(rootPath, k);
+                if (! jsonDropColumns.contains(newPath)) {
+                    Value visited = visit(newPath, v);
+                    newValue.add(i++, k);
+                    newValue.add(i++, visited);
+                }
+            }
+        }
+        else if (this.jsonColumns.containsKey(rootPath)) {
+            Map<Value, Value> map = mapValue.map();
+            for (JsonColumn jsonColumn : jsonColumns.get(rootPath).values()) {
+                Value k = jsonColumn.getElementPathValue();
+                Value v = map.get(k);
+                String newPath = jsonColumn.getName();
+                Value visited = visit(newPath, v);
+                if (visited == null) {
+                    visited = jsonColumn.getDefaultValue();
+                }
+                newValue.add(i++, k);
+                newValue.add(i++, visited);
+            }
+        }
+        else {
+            for (Map.Entry<Value, Value> entry : mapValue.entrySet()) {
+                Value k = entry.getKey();
+                Value v = entry.getValue();
+                String newPath = newMapJsonPath(rootPath, k);
+                Value visited = visit(newPath, v);
+                newValue.add(i++, k);
+                newValue.add(i++, visited);
+            }
+        }
+        if (this.jsonAddColumns.containsKey(rootPath)) {
+            for (JsonColumn jsonColumn : this.jsonAddColumns.get(rootPath).values()) {
+                newValue.add(i++, jsonColumn.getElementPathValue());
+                newValue.add(i++, jsonColumn.getDefaultValue());
+            }
+        }
+        return ValueFactory.newMap(newValue.toArray(new Value[0]), true);
+    }
+
+    public Value visit(String rootPath, Value value)
+    {
+        if (! shouldVisit(rootPath)) {
+            return value;
+        }
+        if (value.isArrayValue()) {
+            return visitArray(rootPath, value.asArrayValue());
+        }
+        else if (value.isMapValue()) {
+            return visitMap(rootPath, value.asMapValue());
+        }
+        else {
+            return value;
+        }
+    }
+}