dev-modify-existing-timeseries

JPS_BASE_LIB/pom.xml

@@ -10,7 +10,7 @@
 
     <!-- Please refer to the Versioning page on TheWorldAvatar wiki for
     details on how version numbers should be selected -->
-    <version>1.45.0</version>
+    <version>1.46.0-dev-modify-existing-timeseries-SNAPSHOT</version>
 
     <!-- Project Properties -->
     <properties>

JPS_BASE_LIB/src/main/java/uk/ac/cam/cares/jps/base/timeseries/TimeSeriesClient.java

@@ -1341,6 +1341,41 @@ public void bulkInitTimeSeries(List<List<String>> dataIRIs, List<List<Class<?>>>
         }
     }
 
+    /**
+     * add columns to an existing timeseries, srid is only used when one of the new
+     * columns has the geometry type, can be null
+     * 
+     * @param timeSeriesIri
+     * @param dataIri
+     * @param classes
+     * @param srid
+     * @param conn
+     */
+    public void addColumnsToExistingTimeSeries(String timeSeriesIri, List<String> dataIri, List<Class<?>> classes,
+            Integer srid, Connection conn) {
+        if (rdbClient.checkAnyDataHasTimeSeries(dataIri, conn) != null) {
+            throw new JPSRuntimeException(
+                    exceptionPrefix + "one or more provided data IRI contains an existing time series");
+        }
+
+        if (!rdbClient.timeSeriesExists(timeSeriesIri, conn)) {
+            throw new JPSRuntimeException(
+                    exceptionPrefix + "provided time series does not exist");
+        }
+
+        rdfClient.addDataToExistingTimeSeries(dataIri, timeSeriesIri);
+        rdbClient.addColumnsToExistingTimeSeries(dataIri, classes, timeSeriesIri, srid, conn);
+    }
+
+    public void addColumnsToExistingTimeSeries(String timeSeriesIri, List<String> dataIri, List<Class<?>> classes,
+            Integer srid) {
+        try (Connection conn = rdbClient.getConnection()) {
+            addColumnsToExistingTimeSeries(timeSeriesIri, dataIri, classes, srid, conn);
+        } catch (SQLException e) {
+            throw new JPSRuntimeException(exceptionPrefix + CONNECTION_ERROR, e);
+        }
+    }
+
     public String getRdbUrl() {
         return rdbClient.getRdbURL();
     }

JPS_BASE_LIB/src/main/java/uk/ac/cam/cares/jps/base/timeseries/TimeSeriesRDBClient.java

@@ -1696,6 +1696,79 @@ public void deleteAll() {
         }
     }
 
+    /**
+     * Adds columns to an existing time series table, set srid to null if no
+     * geometry columns are required
+     */
+    @Override
+    public void addColumnsToExistingTimeSeries(List<String> dataIRIs, List<Class<?>> dataClasses, String tsIri,
+            Integer srid, Connection conn) {
+        DSLContext context = DSL.using(conn);
+
+        // there is already a check on whether time series exists before this method is
+        // called
+        String tsTableName = context.select(TABLENAME_COLUMN).from(getDSLTable(DB_TABLE_NAME))
+                .where(TS_IRI_COLUMN.eq(tsIri)).fetch(TABLENAME_COLUMN).get(0);
+
+        List<String> existingColumns = context.select(COLUMNNAME_COLUMN).from(getDSLTable(DB_TABLE_NAME))
+                .where(TS_IRI_COLUMN.eq(tsIri)).fetch(COLUMNNAME_COLUMN);
+
+        int largestNum = 0;
+        for (String column : existingColumns) {
+            // extract number
+            int number = Integer.parseInt(column.split("column")[1]);
+            if (number > largestNum) {
+                largestNum = number;
+            }
+        }
+
+        // Assign column name for each dataIRI; name for time column is fixed
+        Map<String, String> dataColumnNames = new HashMap<>();
+        largestNum++;
+        for (String s : dataIRIs) {
+            dataColumnNames.put(s, "column" + largestNum);
+            largestNum++;
+        }
+
+        // Add corresponding entries in central lookup table
+        populateCentralTable(tsTableName, dataIRIs, dataColumnNames, tsIri, conn);
+
+        List<String> additionalGeomColumns = new ArrayList<>();
+        List<Class<?>> classForAdditionalGeomColumns = new ArrayList<>();
+
+        List<Query> allSteps = new ArrayList<>();
+        for (int i = 0; i < dataIRIs.size(); i++) {
+            if (Geometry.class.isAssignableFrom(dataClasses.get(i))) {
+                // these columns will be added with their respective restrictions
+                additionalGeomColumns.add(dataColumnNames.get(dataIRIs.get(i)));
+                classForAdditionalGeomColumns.add(dataClasses.get(i));
+            } else {
+                allSteps.add(context.alterTable(getDSLTable(tsTableName)).add(dataColumnNames.get(dataIRIs.get(i)),
+                        DefaultDataType.getDataType(DIALECT, dataClasses.get(i))));
+            }
+        }
+
+        context.batch(allSteps).execute();
+
+        // add remaining geometry columns with restrictions
+        try {
+            if (!additionalGeomColumns.isEmpty()) {
+                addGeometryColumns(tsTableName, additionalGeomColumns, classForAdditionalGeomColumns, srid, conn);
+            }
+        } catch (SQLException e) {
+            String errmsg = "Failed to add geometry columns";
+            LOGGER.error(errmsg);
+            LOGGER.error(e.getMessage());
+            throw new JPSRuntimeException(errmsg, e);
+        }
+    }
+
+    @Override
+    public boolean timeSeriesExists(String tsIRI, Connection conn) {
+        DSLContext context = DSL.using(conn);
+        return context.fetchExists(selectFrom(getDSLTable(DB_TABLE_NAME)).where(TS_IRI_COLUMN.eq(tsIRI)));
+    }
+
     @Override
     public Connection getConnection() throws SQLException {
         try {

JPS_BASE_LIB/src/main/java/uk/ac/cam/cares/jps/base/timeseries/TimeSeriesRDBClientInterface.java

@@ -78,7 +78,7 @@ void initTimeSeriesTable(List<String> dataIRI, List<Class<?>> dataClass, String
      * @param dataClasses
      * @param tsIRIs
      * @param srid
-     * @param conn      connection to the RDB
+     * @param conn        connection to the RDB
      * @return
      */
     List<Integer> bulkInitTimeSeriesTable(List<List<String>> dataIRIs, List<List<Class<?>>> dataClasses,
@@ -378,11 +378,25 @@ List<Integer> bulkInitTimeSeriesTable(List<List<String>> dataIRIs, List<List<Cla
      * Check if all given data IRI is attached to a time series in kb
      * 
      * @param dataIRIs data IRIs provided as list of string
-     * @param conn    connection to the RDB
+     * @param conn     connection to the RDB
      * @return the first dataIRI that exists and is attached to a time series, null
      *         otherwise
      */
     String checkAnyDataHasTimeSeries(List<String> dataIRIs, Connection conn);
 
+    /**
+     * Add columns to an existing time series
+     * 
+     * @param dataIRIs    list of data IRI
+     * @param dataClasses corresponding class of data
+     * @param tsIri       IRI of time series
+     * @param srid        srid for geometry types
+     * @param conn        SQL connection to RDB
+     */
+    void addColumnsToExistingTimeSeries(List<String> dataIRIs, List<Class<?>> dataClasses, String tsIri, Integer srid,
+            Connection conn);
+
+    boolean timeSeriesExists(String tsIRI, Connection conn);
+
     Connection getConnection() throws SQLException;
 }

JPS_BASE_LIB/src/main/java/uk/ac/cam/cares/jps/base/timeseries/TimeSeriesRDBClientWithReducedTables.java

@@ -282,7 +282,7 @@ public List<Integer> bulkInitTimeSeriesTable(List<List<String>> dataIRIs, List<L
 
         List<Map<String, String>> dataColumnNamesMaps = new ArrayList<>();
 
-        TimeSeriesDatabaseMetadata timeSeriesDatabaseMetadata = new TimeSeriesDatabaseMetadata();
+        TimeSeriesDatabaseMetadata timeSeriesDatabaseMetadata = getTimeSeriesDatabaseMetadata(conn, tsTableName);
 
         for (int i = 0; i < dataIRIs.size(); i++) {
             try {
@@ -1683,6 +1683,58 @@ public void deleteAll() {
         }
     }
 
+    @Override
+    public void addColumnsToExistingTimeSeries(List<String> dataIRIs, List<Class<?>> dataClasses, String tsIri,
+            Integer srid, Connection conn) {
+        DSLContext context = DSL.using(conn);
+        String tsTableName = getTableWithMatchingTimeColumn(conn);
+
+        // Assign column name for each dataIRI; name for time column is fixed
+        Map<String, String> dataColumnNames = new HashMap<>();
+
+        List<String> existingColumns = context.select(COLUMNNAME_COLUMN).from(getDSLTable(DB_TABLE_NAME))
+                .where(TS_IRI_COLUMN.eq(tsIri)).fetch(COLUMNNAME_COLUMN);
+
+        if (tsTableName != null) {
+            TimeSeriesDatabaseMetadata timeSeriesDatabaseMetadata = getTimeSeriesDatabaseMetadata(conn,
+                    tsTableName, existingColumns);
+            List<Boolean> hasMatchingColumn = timeSeriesDatabaseMetadata.hasMatchingColumn(dataClasses, srid);
+
+            for (int i = 0; i < hasMatchingColumn.size(); i++) {
+                if (Boolean.TRUE.equals(hasMatchingColumn.get(i))) {
+                    // use existing column
+                    String existingSuitableColumn = timeSeriesDatabaseMetadata
+                            .getExistingSuitableColumn(dataClasses.get(i), srid);
+                    dataColumnNames.put(dataIRIs.get(i), existingSuitableColumn);
+                } else {
+                    // add new columns
+                    int columnIndex = getNumberOfDataColumns(tsTableName, conn) + 1;
+                    String columnName = PREFIX_COLUMN + columnIndex;
+                    try {
+                        addColumn(tsTableName, dataClasses.get(i), columnName, srid, conn);
+                    } catch (SQLException e) {
+                        String errmsg = "Failed to add column for " + dataClasses.get(i).getSimpleName();
+                        LOGGER.error(errmsg);
+                        throw new JPSRuntimeException(errmsg);
+                    }
+
+                    dataColumnNames.put(dataIRIs.get(i), columnName);
+                }
+            }
+        } else {
+            String errmsg = "Probably the wrong time class is initialised for TimeSeriesClient";
+            throw new JPSRuntimeException(exceptionPrefix + errmsg);
+        }
+
+        populateCentralTable(tsTableName, dataIRIs, dataColumnNames, tsIri, conn);
+    }
+
+    @Override
+    public boolean timeSeriesExists(String tsIRI, Connection conn) {
+        DSLContext context = DSL.using(conn);
+        return context.fetchExists(selectFrom(getDSLTable(DB_TABLE_NAME)).where(TS_IRI_COLUMN.eq(tsIRI)));
+    }
+
     @Override
     public Connection getConnection() throws SQLException {
         try {
@@ -1715,15 +1767,21 @@ private Table<Record> getDSLTable(String tableName) {
      * 
      * @param conn
      * @param tableName
+     * @param columnsToExclude // used when adding new columns
      * @return
      */
-    private TimeSeriesDatabaseMetadata getTimeSeriesDatabaseMetadata(Connection conn, String tableName) {
+    private TimeSeriesDatabaseMetadata getTimeSeriesDatabaseMetadata(Connection conn, String tableName,
+            List<String> columnsToExclude) {
         TimeSeriesDatabaseMetadata timeSeriesDatabaseMetadata = new TimeSeriesDatabaseMetadata();
-        addDataTypes(conn, timeSeriesDatabaseMetadata, tableName);
+        addDataTypes(conn, timeSeriesDatabaseMetadata, tableName, columnsToExclude);
         addSpecificGeometryClass(conn, timeSeriesDatabaseMetadata, tableName);
         return timeSeriesDatabaseMetadata;
     }
 
+    private TimeSeriesDatabaseMetadata getTimeSeriesDatabaseMetadata(Connection conn, String tableName) {
+        return getTimeSeriesDatabaseMetadata(conn, tableName, new ArrayList<>());
+    }
+
     /**
      * obtains data from the information_schema.columns table on the initialised
      * time series columns
@@ -1733,7 +1791,7 @@ private TimeSeriesDatabaseMetadata getTimeSeriesDatabaseMetadata(Connection conn
      * @param tableName
      */
     private void addDataTypes(Connection conn, TimeSeriesDatabaseMetadata timeSeriesDatabaseMetadata,
-            String tableName) {
+            String tableName, List<String> columnsToExclude) {
         DSLContext context = DSL.using(conn, DIALECT);
         Field<String> dataTypeColumn = DSL.field("data_type", String.class);
         Field<String> udtNameColumn = DSL.field("udt_name", String.class);
@@ -1749,7 +1807,7 @@ private void addDataTypes(Connection conn, TimeSeriesDatabaseMetadata timeSeries
                 .select(dataTypeColumn, udtNameColumn, COLUMNNAME_COLUMN).from(COLUMNS_TABLE)
                 .where(condition).fetch();
 
-        queryResult.forEach(rec -> {
+        queryResult.stream().filter(rec -> !columnsToExclude.contains(rec.get(COLUMNNAME_COLUMN))).forEach(rec -> {
             String dataType = rec.get(dataTypeColumn);
             String udtName = rec.get(udtNameColumn);
             String columnName = rec.get(COLUMNNAME_COLUMN);

JPS_BASE_LIB/src/main/java/uk/ac/cam/cares/jps/base/timeseries/TimeSeriesSparql.java

@@ -972,6 +972,20 @@ boolean hasAnyExistingTimeSeries(List<String> dataIriList) {
         } else {
             return anyExist;
         }
+    }
+
+    /**
+     * 
+     * @param dataIriList
+     * @param tsIri
+     */
+    void addDataToExistingTimeSeries(List<String> dataIriList, String tsIri) {
+        ModifyQuery modify = Queries.MODIFY();
+
+        dataIriList.forEach(dataIri -> modify.insert(iri(dataIri).has(hasTimeSeries, iri(tsIri))));
 
+        modify.prefix(PREFIX_ONTOLOGY);
+
+        kbClient.executeUpdate(modify.getQueryString());
     }
 }

JPS_BASE_LIB/src/test/java/uk/ac/cam/cares/jps/base/timeseries/TimeSeriesClientIntegrationTest.java

@@ -664,4 +664,23 @@ void testBulkInitTimeSeries() throws SQLException {
             Assertions.assertEquals(dataIRI_2.size(), ts2.getDataIRIs().size());
         }
     }
+
+    @Test
+    void testAddNewColumns() throws SQLException {
+        try (Connection conn = rdbStoreClient.getConnection()) {
+            tsClient.initTimeSeries(dataIRI_1, dataClass_1, timeUnit, conn);
+
+            // if there are no errors it can be assumed it is initialised correctly
+            tsClient.getTimeSeries(dataIRI_1, conn);
+
+            TimeSeriesSparql timeSeriesSparql = new TimeSeriesSparql(kbClient);
+            String tsIri = timeSeriesSparql.getTimeSeries(dataIRI_1.get(0));
+
+            tsClient.addColumnsToExistingTimeSeries(tsIri, dataIRI_2, dataClass_2, null, conn);
+
+            List<String> combinedList = new ArrayList<>(dataIRI_1);
+            combinedList.addAll(dataIRI_2);
+            tsClient.getTimeSeries(combinedList, conn);
+        }
+    }
 }

JPS_BASE_LIB/src/test/java/uk/ac/cam/cares/jps/base/timeseries/TimeSeriesClientIntegrationWithoutConnTest.java

@@ -422,4 +422,21 @@ void testBulkInitTimeSeries() {
         TimeSeries<Instant> ts2 = tsClient.getTimeSeries(dataIRI_2);
         Assertions.assertEquals(dataIRI_2.size(), ts2.getDataIRIs().size());
     }
+
+    @Test
+    void testAddNewColumns() {
+        tsClient.initTimeSeries(dataIRI_1, dataClass_1, timeUnit);
+
+        // if there are no errors it can be assumed it is initialised correctly
+        tsClient.getTimeSeries(dataIRI_1);
+
+        TimeSeriesSparql timeSeriesSparql = new TimeSeriesSparql(kbClient);
+        String tsIri = timeSeriesSparql.getTimeSeries(dataIRI_1.get(0));
+
+        tsClient.addColumnsToExistingTimeSeries(tsIri, dataIRI_2, dataClass_2, null);
+
+        List<String> combinedList = new ArrayList<>(dataIRI_1);
+        combinedList.addAll(dataIRI_2);
+        tsClient.getTimeSeries(combinedList);
+    }
 }