Github user arjansh commented on a diff in the pull request:
https://github.com/apache/metamodel/pull/179#discussion_r190142943
--- Diff:
neo4j/src/main/java/org/apache/metamodel/neo4j/utils/ColumnTypeResolver.java ---
@@ -0,0 +1,117 @@
+/**
+ * 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.metamodel.neo4j.utils;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.metamodel.schema.ColumnType;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class ColumnTypeResolver {
+ public ColumnType[] getColumnTypes(final JSONObject jsonObject, final
String[] columnNamesArray) {
+ final List<String> columnNames = new
ArrayList<>(Arrays.asList(columnNamesArray));
+ final List<ColumnType> columnTypes = new ArrayList<>();
+
+ try {
+ fillColumnTypesFromMetadata(jsonObject, columnNames,
columnTypes);
+ fillColumnTypesFromData(jsonObject, columnNames, columnTypes);
+ } catch (final JSONException e) {
+ // ignore missing data
+ }
+
+ fillColumnTypesFromRemainingColumns(columnNames, columnTypes);
+ return columnTypes.toArray(new ColumnType[columnTypes.size()]);
+ }
+
+ private void fillColumnTypesFromData(final JSONObject jsonObject,
final List<String> columnNames,
+ final List<ColumnType> columnTypes) throws JSONException {
+ final String dataKey = "data";
+
+ if (jsonObject.has(dataKey)) {
+ final JSONObject data = jsonObject.getJSONObject(dataKey);
+ final Iterator keysIterator = data.keys();
+
+ while (keysIterator.hasNext()) {
+ final String key = (String) keysIterator.next();
+ final ColumnType type = getTypeFromValue(data, key);
+ columnTypes.add(type);
+ removeIfAvailable(columnNames, key);
+ }
+ }
+ }
+
+ private void fillColumnTypesFromMetadata(final JSONObject jsonObject,
final List<String> columnNames,
+ final List<ColumnType> columnTypes) throws JSONException {
+ final String metadataKey = "metadata";
+
+ if (jsonObject.has(metadataKey)) {
+ final JSONObject metadata =
jsonObject.getJSONObject(metadataKey);
+
+ if (metadata.has("id")) {
+ columnTypes.add(ColumnType.BIGINT);
+ removeIfAvailable(columnNames, "_id");
+ }
+ }
+ }
+
+ private void fillColumnTypesFromRemainingColumns(final List<String>
columnNames,
+ final List<ColumnType> columnTypes) {
+ for (final String remainingColumnName : columnNames) {
+ if (remainingColumnName.contains("rel_")) {
+ if (remainingColumnName.contains("#")) {
+ columnTypes.add(ColumnType.ARRAY);
+ } else {
+ columnTypes.add(ColumnType.BIGINT);
+ }
+ } else {
+ columnTypes.add(ColumnType.STRING);
+ }
+ }
+ }
+
+ private void removeIfAvailable(final List<String> list, final String
key) {
+ if (list.contains(key)) {
+ list.remove(key);
+ }
+ }
+
+ private ColumnType getTypeFromValue(final JSONObject data, final
String key) {
--- End diff --
Instead of implementing the algorithm to determine the type in here using a
Chain of Responsibility pattern, maybe just use some good old "if ... else"
statements, something like this:
```
try {
Class<? extends Object> keyClass = data.get(key).getClass();
if (keyClass.equals(Boolean.class)) {
return ColumnType.BOOLEAN;
} else if (keyClass.equals(Integer.class)) {
return ColumnType.INTEGER;
} else if (keyClass.equals(Long.class)) {
return ColumnType.BIGINT;
} else if (keyClass.equals(Double.class)) {
return ColumnType.DOUBLE;
} else if (keyClass.equals(Map.class)) {
return ColumnType.MAP;
} else if (keyClass.equals(JSONArray.class)) {
return ColumnType.ARRAY;
}
} catch (JSONException e) {
// TODO: Log something
}
return ColumnType.STRING;
```
In this manner you don't depend on exceptions to indicate a column isn't of
a certain type and you don't need loads of code and even though this contains
quite a number of "if ... else" statements, it is clear to everyone who sees
the code what it is trying to achieve.
Note that I haven't tested the MAP and ARRAY parts in this code, so they
may be incorrect :)
---
