Model and store column lineage in Marquez DB

CHANGELOG.md

@@ -1,6 +1,9 @@
 # Changelog
 
 ## [Unreleased](https://github.com/MarquezProject/marquez/compare/0.26.0...HEAD)
+* Store column lineage facets in separate table [`#2096`](https://github.com/MarquezProject/marquez/pull/2096) [@mzareba382](https://github.com/mzareba382) [@pawel-big-lebowski](https://github.com/pawel-big-lebowski)
+
+
 ## [0.26.0](https://github.com/MarquezProject/marquez/compare/0.25.0...0.26.0) - 2022-09-15
 
 ### Added

api/src/main/java/marquez/db/BaseDao.java

@@ -50,4 +50,7 @@ public interface BaseDao extends SqlObject {
 
   @CreateSqlObject
   OpenLineageDao createOpenLineageDao();
+
+  @CreateSqlObject
+  ColumnLevelLineageDao createColumnLevelLineageDao();
 }

api/src/main/java/marquez/db/ColumnLevelLineageDao.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2018-2022 contributors to the Marquez project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package marquez.db;
+
+import java.time.Instant;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+import marquez.db.mappers.ColumnLevelLineageRowMapper;
+import marquez.db.models.ColumnLevelLineageRow;
+import org.apache.commons.lang3.tuple.Pair;
+import org.jdbi.v3.sqlobject.config.RegisterRowMapper;
+import org.jdbi.v3.sqlobject.customizer.BindBeanList;
+import org.jdbi.v3.sqlobject.statement.SqlQuery;
+import org.jdbi.v3.sqlobject.statement.SqlUpdate;
+
+@RegisterRowMapper(ColumnLevelLineageRowMapper.class)
+public interface ColumnLevelLineageDao extends BaseDao {
+
+  default List<ColumnLevelLineageRow> upsertColumnLevelLineageRow(
+      UUID outputDatasetVersionUuid,
+      UUID outputDatasetFieldUuid,
+      List<Pair<UUID, UUID>> inputs,
+      String transformationDescription,
+      String transformationType,
+      Instant now) {
+
+    if (inputs.isEmpty()) {
+      return Collections.emptyList();
+    }
+
+    List<ColumnLevelLineageRow> rows =
+        inputs.stream()
+            .map(
+                input ->
+                    new ColumnLevelLineageRow(
+                        outputDatasetVersionUuid,
+                        outputDatasetFieldUuid,
+                        input.getLeft(), // input_dataset_version_uuid
+                        input.getRight(), // input_dataset_field_uuid
+                        transformationDescription,
+                        transformationType,
+                        now,
+                        now))
+            .collect(Collectors.toList());
+    doUpsertColumnLevelLineageRow(rows.toArray(new ColumnLevelLineageRow[0]));
+    return findColumnLevelLineageByDatasetVersionColumnAndOutputDatasetField(
+        outputDatasetVersionUuid, outputDatasetFieldUuid);
+  }
+
+  @SqlQuery(
+      "SELECT * FROM column_level_lineage WHERE output_dataset_version_uuid = :datasetVersionUuid AND output_dataset_field_uuid = :outputDatasetFieldUuid")
+  List<ColumnLevelLineageRow> findColumnLevelLineageByDatasetVersionColumnAndOutputDatasetField(
+      UUID datasetVersionUuid, UUID outputDatasetFieldUuid);
+
+  @SqlUpdate(
+      """
+          INSERT INTO column_level_lineage (
+          output_dataset_version_uuid,
+          output_dataset_field_uuid,
+          input_dataset_version_uuid,
+          input_dataset_field_uuid,
+          transformation_description,
+          transformation_type,
+          created_at,
+          updated_at
+          ) VALUES <values>
+          ON CONFLICT (output_dataset_version_uuid, output_dataset_field_uuid, input_dataset_version_uuid, input_dataset_field_uuid)
+          DO UPDATE SET
+          transformation_description = EXCLUDED.transformation_description,
+          transformation_type = EXCLUDED.transformation_type,
+          updated_at = EXCLUDED.updated_at
+          RETURNING *
+          """)
+  void doUpsertColumnLevelLineageRow(
+      @BindBeanList(
+              propertyNames = {
+                "outputDatasetVersionUuid",
+                "outputDatasetFieldUuid",
+                "inputDatasetVersionUuid",
+                "inputDatasetFieldUuid",
+                "transformationDescription",
+                "transformationType",
+                "createdAt",
+                "updatedAt"
+              },
+              value = "values")
+          ColumnLevelLineageRow... rows);
+}

api/src/main/java/marquez/db/Columns.java

@@ -126,6 +126,15 @@ private Columns() {}
   public static final String RUN_UUID = "run_uuid";
   public static final String STATE = "state";
 
+  /* COLUMN LEVEL LINEAGE ROW COLUMNS */
+  public static final String FIELD_NAME = "field_name";
+  public static final String OUTPUT_DATASET_VERSION_UUID = "output_dataset_version_uuid";
+  public static final String OUTPUT_DATASET_FIELD_UUID = "output_dataset_field_uuid";
+  public static final String INPUT_DATASET_FIELD_UUID = "input_dataset_field_uuid";
+  public static final String INPUT_DATASET_VERSION_UUID = "input_dataset_version_uuid";
+  public static final String TRANSFORMATION_DESCRIPTION = "transformation_description";
+  public static final String TRANSFORMATION_TYPE = "transformation_type";
+
   /* LINEAGE EVENT ROW COLUMNS */
   public static final String EVENT = "event";
 

api/src/main/java/marquez/db/DatasetFieldDao.java

@@ -16,8 +16,10 @@
 import marquez.common.models.TagName;
 import marquez.db.mappers.DatasetFieldMapper;
 import marquez.db.mappers.DatasetFieldRowMapper;
+import marquez.db.mappers.FieldDataMapper;
 import marquez.db.models.DatasetFieldRow;
 import marquez.db.models.DatasetRow;
+import marquez.db.models.InputFieldData;
 import marquez.db.models.TagRow;
 import marquez.service.models.Dataset;
 import marquez.service.models.DatasetVersion;
@@ -29,6 +31,7 @@
 
 @RegisterRowMapper(DatasetFieldRowMapper.class)
 @RegisterRowMapper(DatasetFieldMapper.class)
+@RegisterRowMapper(FieldDataMapper.class)
 public interface DatasetFieldDao extends BaseDao {
   @SqlQuery(
       "SELECT EXISTS ("
@@ -101,6 +104,24 @@ default Dataset updateTags(
           + "WHERE fm.dataset_version_uuid = :datasetVersionUuid")
   List<Field> find(UUID datasetVersionUuid);
 
+  @SqlQuery(
+      """
+          SELECT
+            datasets_view.namespace_name as namespace_name,
+            datasets_view.name as dataset_name,
+            dataset_fields.name as field_name,
+            datasets_view.uuid as dataset_uuid,
+            dataset_versions.uuid as dataset_version_uuid,
+            dataset_fields.uuid as dataset_field_uuid
+          FROM dataset_fields
+          JOIN dataset_versions_field_mapping fm ON fm.dataset_field_uuid = dataset_fields.uuid
+          JOIN dataset_versions ON dataset_versions.uuid = fm.dataset_version_uuid
+          JOIN datasets_view ON datasets_view.uuid = dataset_versions.dataset_uuid
+          JOIN runs_input_mapping ON runs_input_mapping.dataset_version_uuid =  dataset_versions.uuid
+          WHERE runs_input_mapping.run_uuid = :runUuid
+          """)
+  List<InputFieldData> findInputFieldsDataAssociatedWithRun(UUID runUuid);
+
   @SqlQuery(
       "INSERT INTO dataset_fields ("
           + "uuid, "

api/src/main/java/marquez/db/OpenLineageDao.java

@@ -13,13 +13,16 @@
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import marquez.common.Utils;
 import marquez.common.models.DatasetId;
 import marquez.common.models.DatasetName;
@@ -31,9 +34,11 @@
 import marquez.db.DatasetFieldDao.DatasetFieldMapping;
 import marquez.db.JobVersionDao.BagOfJobVersionInfo;
 import marquez.db.mappers.LineageEventMapper;
+import marquez.db.models.ColumnLevelLineageRow;
 import marquez.db.models.DatasetFieldRow;
 import marquez.db.models.DatasetRow;
 import marquez.db.models.DatasetVersionRow;
+import marquez.db.models.InputFieldData;
 import marquez.db.models.JobContextRow;
 import marquez.db.models.JobRow;
 import marquez.db.models.NamespaceRow;
@@ -55,6 +60,7 @@
 import marquez.service.models.LineageEvent.RunFacet;
 import marquez.service.models.LineageEvent.SchemaDatasetFacet;
 import marquez.service.models.LineageEvent.SchemaField;
+import org.apache.commons.lang3.tuple.Pair;
 import org.jdbi.v3.sqlobject.config.RegisterRowMapper;
 import org.jdbi.v3.sqlobject.statement.SqlQuery;
 import org.jdbi.v3.sqlobject.statement.SqlUpdate;
@@ -129,6 +135,7 @@ default UpdateLineageRow updateBaseMarquezModel(LineageEvent event, ObjectMapper
     RunDao runDao = createRunDao();
     RunArgsDao runArgsDao = createRunArgsDao();
     RunStateDao runStateDao = createRunStateDao();
+    ColumnLevelLineageDao columnLevelLineageDao = createColumnLevelLineageDao();
 
     Instant now = event.getEventTime().withZoneSameInstant(ZoneId.of("UTC")).toInstant();
 
@@ -320,7 +327,8 @@ default UpdateLineageRow updateBaseMarquezModel(LineageEvent event, ObjectMapper
                 datasetDao,
                 datasetVersionDao,
                 datasetFieldDao,
-                runDao);
+                runDao,
+                columnLevelLineageDao);
         datasetInputs.add(record);
       }
     }
@@ -341,7 +349,8 @@ default UpdateLineageRow updateBaseMarquezModel(LineageEvent event, ObjectMapper
                 datasetDao,
                 datasetVersionDao,
                 datasetFieldDao,
-                runDao);
+                runDao,
+                columnLevelLineageDao);
         datasetOutputs.add(record);
       }
     }
@@ -529,7 +538,8 @@ default DatasetRecord upsertLineageDataset(
       DatasetDao datasetDao,
       DatasetVersionDao datasetVersionDao,
       DatasetFieldDao datasetFieldDao,
-      RunDao runDao) {
+      RunDao runDao,
+      ColumnLevelLineageDao columnLevelLineageDao) {
     NamespaceRow dsNamespace =
         namespaceDao.upsertNamespaceRow(
             UUID.randomUUID(), now, ds.getNamespace(), DEFAULT_NAMESPACE_OWNER);
@@ -621,6 +631,7 @@ default DatasetRecord upsertLineageDataset(
                   return row;
                 });
     List<DatasetFieldMapping> datasetFieldMappings = new ArrayList<>();
+    List<DatasetFieldRow> datasetFields = new ArrayList<>();
     if (fields != null) {
       for (SchemaField field : fields) {
         DatasetFieldRow datasetFieldRow =
@@ -631,6 +642,7 @@ default DatasetRecord upsertLineageDataset(
                 field.getType(),
                 field.getDescription(),
                 datasetRow.getUuid());
+        datasetFields.add(datasetFieldRow);
         datasetFieldMappings.add(
             new DatasetFieldMapping(datasetVersionRow.getUuid(), datasetFieldRow.getUuid()));
       }
@@ -649,7 +661,85 @@ default DatasetRecord upsertLineageDataset(
       }
     }
 
-    return new DatasetRecord(datasetRow, datasetVersionRow, datasetNamespace);
+    List<ColumnLevelLineageRow> columnLineageRows = Collections.emptyList();
+    if (!isInput) {
+      columnLineageRows =
+          upsertColumnLineage(
+              runUuid,
+              ds,
+              now,
+              datasetFields,
+              columnLevelLineageDao,
+              datasetFieldDao,
+              datasetVersionRow);
+    }
+
+    return new DatasetRecord(datasetRow, datasetVersionRow, datasetNamespace, columnLineageRows);
+  }
+
+  private List<ColumnLevelLineageRow> upsertColumnLineage(
+      UUID runUuid,
+      Dataset ds,
+      Instant now,
+      List<DatasetFieldRow> datasetFields,
+      ColumnLevelLineageDao columnLevelLineageDao,
+      DatasetFieldDao datasetFieldDao,
+      DatasetVersionRow datasetVersionRow) {
+    // get all the fields related to this particular run
+    List<InputFieldData> runFields = datasetFieldDao.findInputFieldsDataAssociatedWithRun(runUuid);
+
+    return Optional.ofNullable(ds.getFacets())
+        .map(DatasetFacets::getColumnLineage)
+        .map(LineageEvent.ColumnLineageFacet::getOutputColumnsList)
+        .stream()
+        .flatMap(list -> list.stream())
+        .flatMap(
+            outputColumn -> {
+              Optional<DatasetFieldRow> outputField =
+                  datasetFields.stream()
+                      .filter(dfr -> dfr.getName().equals(outputColumn.getName()))
+                      .findAny();
+
+              if (outputField.isEmpty()) {
+                Logger log = LoggerFactory.getLogger(OpenLineageDao.class);
+                log.error(
+                    "Cannot produce column lineage for missing output field in output dataset: %s",
+                    outputColumn.getName());
+                return Stream.empty();
+              }
+
+              // get field uuids of input columns related to this run
+              List<Pair<UUID, UUID>> inputFields =
+                  runFields.stream()
+                      .filter(
+                          fieldData ->
+                              outputColumn.getInputFields().stream()
+                                  .filter(
+                                      of ->
+                                          of.getDatasetNamespace().equals(fieldData.getNamespace())
+                                              && of.getDatasetName()
+                                                  .equals(fieldData.getDatasetName())
+                                              && of.getFieldName().equals(fieldData.getField()))
+                                  .findAny()
+                                  .isPresent())
+                      .map(
+                          fieldData ->
+                              Pair.of(
+                                  fieldData.getDatasetVersionUuid(),
+                                  fieldData.getDatasetFieldUuid()))
+                      .collect(Collectors.toList());
+
+              return columnLevelLineageDao
+                  .upsertColumnLevelLineageRow(
+                      datasetVersionRow.getUuid(),
+                      outputField.get().getUuid(),
+                      inputFields,
+                      outputColumn.getTransformationDescription(),
+                      outputColumn.getTransformationType(),
+                      now)
+                  .stream();
+            })
+        .collect(Collectors.toList());
   }
 
   default String formatDatasetName(String name) {

api/src/main/java/marquez/db/mappers/ColumnLevelLineageRowMapper.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2018-2022 contributors to the Marquez project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package marquez.db.mappers;
+
+import static marquez.db.Columns.TRANSFORMATION_DESCRIPTION;
+import static marquez.db.Columns.TRANSFORMATION_TYPE;
+import static marquez.db.Columns.stringOrThrow;
+import static marquez.db.Columns.timestampOrThrow;
+import static marquez.db.Columns.uuidOrThrow;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import lombok.NonNull;
+import marquez.db.Columns;
+import marquez.db.models.ColumnLevelLineageRow;
+import org.jdbi.v3.core.mapper.RowMapper;
+import org.jdbi.v3.core.statement.StatementContext;
+
+public class ColumnLevelLineageRowMapper implements RowMapper<ColumnLevelLineageRow> {
+
+  @Override
+  public ColumnLevelLineageRow map(@NonNull ResultSet results, @NonNull StatementContext context)
+      throws SQLException {
+    return new ColumnLevelLineageRow(
+        uuidOrThrow(results, Columns.OUTPUT_DATASET_VERSION_UUID),
+        uuidOrThrow(results, Columns.OUTPUT_DATASET_FIELD_UUID),
+        uuidOrThrow(results, Columns.INPUT_DATASET_VERSION_UUID),
+        uuidOrThrow(results, Columns.INPUT_DATASET_FIELD_UUID),
+        stringOrThrow(results, TRANSFORMATION_DESCRIPTION),
+        stringOrThrow(results, TRANSFORMATION_TYPE),
+        timestampOrThrow(results, Columns.CREATED_AT),
+        timestampOrThrow(results, Columns.UPDATED_AT));
+  }
+}