Work on Foreign Keys

Author: JohannesJander

docs/spec-compliance.md

@@ -45,7 +45,7 @@ Documents compliance with the [specifications](https://frictionlessdata.io/specs
 - Both type and format are optional: in a field descriptor, the absence of a type property indicates that the field 
     is of the type "string", and the absence of a format property indicates that the field's type format is "default".
 
-    - implemented in Fild#fromJson(String) as `String type = fieldDef.has(JSON_KEY_TYPE) 
+    - implemented in `Field#fromJson(String) as `String type = fieldDef.has(JSON_KEY_TYPE) 
     ? fieldDef.getString(JSON_KEY_TYPE) : "string";` and `field.format = (!StringUtils.isEmpty(format)) 
     ? format.trim() : FIELD_FORMAT_DEFAULT`;
 

pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>io.frictionlessdata</groupId>
     <artifactId>tableschema-java</artifactId>
-    <version>0.7.5-SNAPSHOT</version>
+    <version>0.7.6-SNAPSHOT</version>
     <packaging>jar</packaging>
     <issueManagement>
         <url>https://github.com/frictionlessdata/tableschema-java/issues</url>

src/main/java/io/frictionlessdata/tableschema/Table.java

@@ -83,6 +83,11 @@ public Table(Collection<String[]> data, String[] headers, Schema schema) {
             validate();
     }
 
+    /**
+     * Constructor for a Table from a {@link BeanTableDataSource} instance holding a collection
+     * of instances of a certain Bean class. The Schema is inferred from the Bean class.
+     * @param dataSource the input data
+     */
     public static Table fromSource(BeanTableDataSource dataSource) {
         Table table = new Table();
         table.dataSource = dataSource;
@@ -146,25 +151,25 @@ public static Table fromSource(File dataSource, File basePath) {
 
     /**
      * Create Table using either a CSV or JSON array-containing string and without either a Schema or a CSVFormat.
-     * @param dataSource the CSV or JSON content for the Table
+     * @param data the CSV or JSON content for the Table
      */
-    public static Table fromSource(String dataSource) {
+    public static Table fromSource(String data) {
         Table table = new Table();
-        table.dataSource = TableDataSource.fromSource(dataSource);
+        table.dataSource = TableDataSource.fromSource(data);
         return table;
     }
 
     /**
      * Create Table using either a CSV or JSON array-containing string and with  a Schema and a CSVFormat.
-     * @param dataSource the CSV or JSON content for the Table
+     * @param data the CSV or JSON content for the Table
      * @param schema table schema. Can be `null`
      * @param format The expected CSVFormat if dataSource is a CSV-containing InputStream; ignored for JSON data.
      *               Can be `null`
      */
-    public static Table fromSource(String dataSource, Schema schema, CSVFormat format) {
+    public static Table fromSource(String data, Schema schema, CSVFormat format) {
         Table table = new Table();
         table.schema = schema;
-        table.dataSource = TableDataSource.fromSource(dataSource);
+        table.dataSource = TableDataSource.fromSource(data);
         if (null != format) {
             table.setCsvFormat(format);
         }
@@ -450,7 +455,7 @@ private void writeCsv(Writer out, CSVFormat format, String[] sortedHeaders) {
                     ? format
                     : TableDataSource.getDefaultCsvFormat();
 
-            locFormat = locFormat.builder().setHeader(sortedHeaders).build();
+            locFormat = locFormat.builder().setHeader(sortedHeaders).get();
             CSVPrinter csvPrinter = new CSVPrinter(out, locFormat);
 
             String[] headers = getHeaders();

src/main/java/io/frictionlessdata/tableschema/exception/ConstraintsException.java

@@ -9,7 +9,7 @@
  *
  * @author pechorin
  */
-public class ConstraintsException extends TableSchemaException {
+public class ConstraintsException extends ValidationException {
 
     /**
      * Constructs an instance of <code>ConstraintsException</code> with the

src/main/java/io/frictionlessdata/tableschema/exception/ForeignKeyException.java

@@ -3,7 +3,7 @@
 /**
  *
  */
-public class ForeignKeyException extends TableSchemaException {
+public class ForeignKeyException extends ValidationException {
 
     /**
      * Constructs an instance of <code>ForeignKeyException</code> with the

src/main/java/io/frictionlessdata/tableschema/exception/PrimaryKeyException.java

@@ -1,6 +1,6 @@
 package io.frictionlessdata.tableschema.exception;
 
-public class PrimaryKeyException extends TableSchemaException {
+public class PrimaryKeyException extends ValidationException {
 
     public PrimaryKeyException(String msg) {
         super(msg);

src/main/java/io/frictionlessdata/tableschema/exception/TableValidationException.java

@@ -4,7 +4,7 @@
  *
  *
  */
-public class TableValidationException extends TableSchemaException {
+public class TableValidationException extends ValidationException {
 
 
     /**
@@ -17,12 +17,4 @@ public TableValidationException(String msg) {
         super(msg);
     }
 
-    /**
-     * Constructs an instance of <code>TableSchemaException</code> by wrapping a Throwable
-     *
-     * @param t the wrapped exception.
-     */
-    public TableValidationException(Throwable t) {
-        super(t);
-    }
 }

src/main/java/io/frictionlessdata/tableschema/exception/ValidationException.java

@@ -8,16 +8,15 @@
 import java.util.stream.Collectors;
 
 public class ValidationException extends TableSchemaException {
-
 	List<ValidationMessage> validationMessages = new ArrayList<>();
-	List<String> otherMessages = new ArrayList<>();
+	List<Exception> wrappedExceptions = new ArrayList<>();
 
 	public ValidationException(String msg) {
 		super(msg);
 	}
 
 	public ValidationException(Exception ex) {
-		String message = ex.getClass()+": "+ex.getMessage();
+		wrappedExceptions.add(ex);
 	}
 
 	public ValidationException(FormalSchemaValidator schema, Collection<ValidationMessage> messages) {
@@ -32,19 +31,30 @@ public ValidationException(String message, String schemaName, Collection<Validat
 
 	public ValidationException(String schemaName, Collection<ValidationException> exceptions) {
 		this(String.format("%s: %s", schemaName, "validation failed: "));
-		otherMessages.addAll(exceptions
-				.stream().map((Throwable::getMessage)).collect(Collectors.toList()));
+		wrappedExceptions.addAll(exceptions);
 		final Set<ValidationMessage> messages = new LinkedHashSet<>();
 		exceptions.forEach((m) -> {
-			messages.addAll(m.validationMessages);
+			if (m instanceof ValidationException) {
+				messages.addAll(((ValidationException)m).validationMessages);
+			}
 		});
 		this.validationMessages.addAll(messages);
 	}
 
+	public List<Exception> getWrappedExceptions() {
+		return wrappedExceptions;
+	}
+
+	public List<ValidationMessage> getValidationMessages() {
+		return validationMessages;
+	}
+
 	public List<Object> getMessages() {
 		List<Object> retVal = new ArrayList<>();
 		retVal.addAll(validationMessages);
-		retVal.addAll(otherMessages);
+		for (Exception ex : wrappedExceptions) {
+			retVal.add(ex.getMessage());
+		}
 		return retVal;
 	}
 }

src/main/java/io/frictionlessdata/tableschema/fk/ForeignKey.java

@@ -1,10 +1,10 @@
 package io.frictionlessdata.tableschema.fk;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import io.frictionlessdata.tableschema.Table;
 import io.frictionlessdata.tableschema.exception.ForeignKeyException;
+import io.frictionlessdata.tableschema.exception.ValidationException;
 import io.frictionlessdata.tableschema.util.JsonUtil;
 
 import java.util.*;
@@ -15,55 +15,43 @@
 public class ForeignKey {
     private static final String JSON_KEY_FIELDS = "fields";
     private static final String JSON_KEY_REFERENCE = "reference";
-    
+
+    @JsonProperty(JSON_KEY_FIELDS)
     private Object fields = null;
+
+    @JsonProperty(JSON_KEY_REFERENCE)
     private Reference reference = null;
 
-    private boolean strictValidation = false;
-    private final ArrayList<Exception> errors = new ArrayList<>();
-    
-    public ForeignKey(){   
-    }
+    private boolean strictValidation = true;
+    private final ArrayList<ValidationException> errors = new ArrayList<>();
 
-    public ForeignKey(boolean strict){  
-        this();
-        this.strictValidation = strict;
-    }
+    public ForeignKey(){}
 
     public ForeignKey(Object fields, Reference reference, boolean strict) throws ForeignKeyException{
         this.fields = fields;
         this.reference = reference;
         this.strictValidation = strict;
         this.validate();
     }
-    
-    public ForeignKey(String json, boolean strict) throws ForeignKeyException{
-        JsonNode fkJsonObject = JsonUtil.getInstance().readValue(json);
-        this.strictValidation = strict;
-        
-        if(fkJsonObject.has(JSON_KEY_FIELDS)){
-        	if(fkJsonObject.get(JSON_KEY_FIELDS).isArray()) {
-        		fields = fkJsonObject.get(JSON_KEY_FIELDS);
-        	} else {
-        		fields = fkJsonObject.get(JSON_KEY_FIELDS).asText();
-        	}
-        }
-        
-        if(fkJsonObject.has(JSON_KEY_REFERENCE)){
-            JsonNode refJsonObject = fkJsonObject.get(JSON_KEY_REFERENCE);
-            reference = new Reference(refJsonObject.toString(), strict);
-        }
-        
-        validate();
-    }
-    
+
     public void setFields(Object fields){
         this.fields = fields;
     }
-    
+
     public <Any> Any getFields(){
         return (Any)this.fields;
     }
+
+    @JsonIgnore
+    public List<String> getFieldNames(){
+        if (this.fields instanceof String){
+            return Collections.singletonList((String)this.fields);
+        } else if (this.fields instanceof Collection){
+            return new ArrayList<>( (Collection<String>)this.fields);
+        } else {
+            throw new IllegalArgumentException("Invalid fields type in reference: "+this.fields.getClass().getName());
+        }
+    }
 
     public void setReference(Reference reference){
         this.reference = reference;
@@ -75,38 +63,51 @@ public Reference getReference(){
 
     public final void validate() throws ForeignKeyException{
         ForeignKeyException fke = null;
-        
+
         if(this.fields == null || this.reference == null){
             fke = new ForeignKeyException("A foreign key must have the fields and reference properties.");
 
-        }else if(!(this.fields instanceof String) && !(this.fields instanceof ArrayNode)){
+        }else if(!(this.fields instanceof String) && !(this.fields instanceof Collection)){
             fke = new ForeignKeyException("The foreign key's fields property must be a string or an array.");
 
-        }else if(this.fields instanceof ArrayNode && !(this.reference.getFields() instanceof ArrayNode)){
+        }else if(this.fields instanceof Collection && !(this.reference.getFields() instanceof Collection)){
             fke = new ForeignKeyException("The reference's fields property must be an array if the outer fields is an array.");
 
         }else if(this.fields instanceof String && !(this.reference.getFields() instanceof String)){
             fke = new ForeignKeyException("The reference's fields property must be a string if the outer fields is a string.");
 
-        }else if(this.fields instanceof ArrayNode && this.reference.getFields() instanceof ArrayNode){
-        	ArrayNode fkFields = (ArrayNode)fields;
-        	ArrayNode refFields = reference.getFields();
+        }else if(this.fields instanceof Collection && this.reference.getFields() instanceof Collection){
+            Collection<?> fkFields = (Collection<?>)fields;
+            Collection<?> refFields = reference.getFields();
 
             if(fkFields.size() != refFields.size()){
                 fke = new ForeignKeyException("The reference's fields property must be an array of the same length as that of the outer fields' array.");
             }
         }
 
+        if (null != reference) {
+            reference.validate();
+        }
+
         if(fke != null){
             if(this.strictValidation){
                 throw fke;  
             }else{
                 errors.add(fke);
+                if (null != reference) {
+                    errors.addAll(reference.getErrors());
+                }
             }           
         }
 
     }
 
+    /**
+     * validate the foreign key against the table. We only can validate self-referencing FKs, as we
+     * do not have access to the tables in different resources of a  datapackages in the tableschema library.
+     * @param table the table to validate against
+     * @throws ForeignKeyException if the foreign key is violated
+     */
     public final void validate(Table table) throws ForeignKeyException{
         validate();
 
@@ -117,10 +118,11 @@ public final void validate(Table table) throws ForeignKeyException{
             if (fields instanceof String) {
                 fieldNames.add((String) fields);
                 foreignFieldNames.add(reference.getFields());
-            } else  if (fields instanceof ArrayNode) {
-                for (int i = 0; i < ((ArrayNode) fields).size(); i++) {
-                    fieldNames.add(((ArrayNode) fields).get(i).asText());
-                    foreignFieldNames.add(((ArrayNode) reference.getFields()).get(i).asText());
+            } else  if (fields instanceof Collection) {
+                List<String> lFields = getFieldNames();
+                for (int i = 0; i < lFields.size(); i++) {
+                    fieldNames.add(lFields.get(i));
+                    foreignFieldNames.add(reference.getFieldNames().get(i));
                 }
             }
             Iterator<Object> iterator = table.iterator(true, false, false, false);
@@ -135,16 +137,19 @@ public final void validate(Table table) throws ForeignKeyException{
                     }
                 }
             }
-         }
+         } else {
+            throw new UnsupportedOperationException("Foreign key references across package resources are not supported");
+        }
 
     }
 
     @JsonIgnore
     public String getJson(){
         return JsonUtil.getInstance().serialize(this);
     }
-    
-    public List<Exception> getErrors(){
+
+    @JsonIgnore
+    public ArrayList<ValidationException> getErrors(){
         return errors;
     }