diff --git a/app/dao/models/cassandra/CassandraGraphVersionFactory.java b/app/dao/models/cassandra/CassandraGraphVersionFactory.java index c5862bf3..d2b3fdbd 100644 --- a/app/dao/models/cassandra/CassandraGraphVersionFactory.java +++ b/app/dao/models/cassandra/CassandraGraphVersionFactory.java @@ -28,10 +28,10 @@ import util.IdGenerator; import java.util.ArrayList; +import java.util.HashSet; import java.util.List; import java.util.Map; -import java.util.stream.Collectors; - +import java.util.Set; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -97,12 +97,12 @@ public GraphVersion create(Map tags, this.dbClient.insert("graph_version", insertions); + List predicate = new ArrayList<>(); + predicate.add(new DbDataContainer("id", GroundType.LONG, id)); for (long edgeVersionId : edgeVersionIds) { - List edgeInsertion = new ArrayList<>(); - edgeInsertion.add(new DbDataContainer("graph_version_id", GroundType.LONG, id)); - edgeInsertion.add(new DbDataContainer("edge_version_id", GroundType.LONG, edgeVersionId)); - - this.dbClient.insert("graph_version_edge", edgeInsertion); + Set edge = new HashSet<>(); + edge.add(edgeVersionId); + this.dbClient.addToSet("graph_version", "edge_version_set", edge, predicate); } this.graphFactory.update(graphId, id, parentIds); @@ -126,26 +126,12 @@ public GraphVersion retrieveFromDatabase(long id) throws GroundException { List predicates = new ArrayList<>(); predicates.add(new DbDataContainer("id", GroundType.LONG, id)); - List edgePredicate = new ArrayList<>(); - edgePredicate.add(new DbDataContainer("graph_version_id", GroundType.LONG, id)); - CassandraResults resultSet = this.dbClient.equalitySelect("graph_version", DbClient.SELECT_STAR, predicates); - long graphId = resultSet.getLong("graph_id"); - - List edgeVersionIds = new ArrayList<>(); - CassandraResults edgeSet = this.dbClient.equalitySelect("graph_version_edge", - DbClient.SELECT_STAR, - edgePredicate); - - if (!edgeSet.isEmpty()) { - do { - edgeVersionIds.add(edgeSet.getLong("edge_version_id")); - } while (edgeSet.next()); - } + List edgeVersionIds = new ArrayList<>(resultSet.getSet("edge_version_set", Long.class)); LOGGER.info("Retrieved graph version " + id + " in graph " + graphId + "."); return new GraphVersion(id, version.getTags(), version.getStructureVersionId(), diff --git a/app/dao/models/cassandra/CassandraStructureVersionFactory.java b/app/dao/models/cassandra/CassandraStructureVersionFactory.java index d56c8a35..eaee941a 100644 --- a/app/dao/models/cassandra/CassandraStructureVersionFactory.java +++ b/app/dao/models/cassandra/CassandraStructureVersionFactory.java @@ -88,13 +88,11 @@ public StructureVersion create(long structureId, this.dbClient.insert("structure_version", insertions); for (String key : attributes.keySet()) { - List itemInsertions = new ArrayList<>(); - itemInsertions.add(new DbDataContainer("structure_version_id", GroundType.LONG, id)); - itemInsertions.add(new DbDataContainer("key", GroundType.STRING, key)); - itemInsertions.add(new DbDataContainer("type", GroundType.STRING, - attributes.get(key).toString())); - - this.dbClient.insert("structure_version_attribute", itemInsertions); + Map map = new HashMap<>(); + map.put(key, attributes.get(key).toString()); + List predicate = new ArrayList<>(); + predicate.add(new DbDataContainer("id", GroundType.LONG, id)); + this.dbClient.addToMap("structure_version", "key_type_map", map, predicate); } this.structureFactory.update(structureId, id, parentIds); @@ -120,21 +118,16 @@ public StructureVersion retrieveFromDatabase(long id) throws GroundException { predicates); super.verifyResultSet(resultSet, id); - Map attributes = new HashMap<>(); - - List attributePredicates = new ArrayList<>(); - attributePredicates.add(new DbDataContainer("structure_version_id", GroundType.LONG, id)); - CassandraResults attributesSet = this.dbClient.equalitySelect("structure_version_attribute", - DbClient.SELECT_STAR, attributePredicates); + Map tmpAttributes = resultSet.getMap("key_type_map", String.class, String.class); - if (attributesSet.isEmpty()) { + if (tmpAttributes.isEmpty()) { throw new GroundException("No StructureVersion attributes found for id " + id + "."); } - do { - attributes.put(attributesSet.getString("key"), GroundType.fromString(attributesSet - .getString("type"))); - } while (attributesSet.next()); + Map attributes = new HashMap<>(); + for (String key : tmpAttributes.keySet()) { + attributes.put(key, GroundType.fromString(tmpAttributes.get(key))); + } long structureId = resultSet.getLong("structure_id"); diff --git a/app/dao/usage/cassandra/CassandraLineageGraphVersionFactory.java b/app/dao/usage/cassandra/CassandraLineageGraphVersionFactory.java index 53a51a56..29d2d284 100644 --- a/app/dao/usage/cassandra/CassandraLineageGraphVersionFactory.java +++ b/app/dao/usage/cassandra/CassandraLineageGraphVersionFactory.java @@ -31,9 +31,10 @@ import util.IdGenerator; import java.util.ArrayList; +import java.util.HashSet; import java.util.List; import java.util.Map; - +import java.util.Set; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -104,13 +105,12 @@ public LineageGraphVersion create(Map tags, this.dbClient.insert("lineage_graph_version", insertions); for (long lineageEdgeVersionId : lineageEdgeVersionIds) { - List lineageEdgeInsertion = new ArrayList<>(); - lineageEdgeInsertion.add(new DbDataContainer("lineage_graph_version_id", GroundType.LONG, - id)); - lineageEdgeInsertion.add(new DbDataContainer("lineage_edge_version_id", GroundType.LONG, - lineageEdgeVersionId)); + List predicates = new ArrayList<>(); + predicates.add(new DbDataContainer("id", GroundType.LONG, id)); + Set edgeValue = new HashSet<>(); + edgeValue.add(lineageEdgeVersionId); - this.dbClient.insert("lineage_graph_version_edge", lineageEdgeInsertion); + this.dbClient.addToSet("lineage_graph_version", "lineage_edge_version_id_set", edgeValue, predicates); } this.lineageGraphFactory.update(lineageGraphId, id, parentIds); @@ -137,8 +137,8 @@ public LineageGraphVersion retrieveFromDatabase(long id) throws GroundException List predicates = new ArrayList<>(); predicates.add(new DbDataContainer("id", GroundType.LONG, id)); - List lineageEdgePredicate = new ArrayList<>(); - lineageEdgePredicate.add(new DbDataContainer("lineage_graph_version_id", GroundType.LONG, + List lineageGraphVersionPredicates = new ArrayList<>(); + lineageGraphVersionPredicates.add(new DbDataContainer("id", GroundType.LONG, id)); CassandraResults resultSet = this.dbClient.equalitySelect("lineage_graph_version", @@ -148,15 +148,7 @@ public LineageGraphVersion retrieveFromDatabase(long id) throws GroundException long lineageGraphId = resultSet.getLong("lineage_graph_id"); - List lineageEdgeVersionIds = new ArrayList<>(); - CassandraResults lineageEdgeSet = this.dbClient.equalitySelect("lineage_graph_version_edge", - DbClient.SELECT_STAR, lineageEdgePredicate); - - if (!lineageEdgeSet.isEmpty()) { - do { - lineageEdgeVersionIds.add(lineageEdgeSet.getLong("lineage_edge_version_id")); - } while (lineageEdgeSet.next()); - } + List lineageEdgeVersionIds = new ArrayList<>(resultSet.getSet("lineage_edge_version_id_set", Long.class)); LOGGER.info("Retrieved lineage_graph version " + id + " in lineage_graph " + lineageGraphId + "."); diff --git a/app/dao/versions/cassandra/CassandraVersionHistoryDagFactory.java b/app/dao/versions/cassandra/CassandraVersionHistoryDagFactory.java index f10cbcb8..abf1abc7 100644 --- a/app/dao/versions/cassandra/CassandraVersionHistoryDagFactory.java +++ b/app/dao/versions/cassandra/CassandraVersionHistoryDagFactory.java @@ -15,13 +15,14 @@ package dao.versions.cassandra; import com.google.common.base.CaseFormat; - import dao.versions.VersionHistoryDagFactory; import db.CassandraClient; -import db.CassandraResults; -import db.DbClient; import db.DbDataContainer; import exceptions.GroundException; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; import models.models.Structure; import models.versions.GroundType; import models.versions.Item; @@ -29,11 +30,6 @@ import models.versions.VersionHistoryDag; import models.versions.VersionSuccessor; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - public class CassandraVersionHistoryDagFactory implements VersionHistoryDagFactory { private final CassandraClient dbClient; private final CassandraVersionSuccessorFactory versionSuccessorFactory; @@ -61,21 +57,14 @@ public VersionHistoryDag create(long itemId) throws Groun @Override public VersionHistoryDag retrieveFromDatabase(long itemId) throws GroundException { - List predicates = new ArrayList<>(); - predicates.add(new DbDataContainer("item_id", GroundType.LONG, itemId)); - CassandraResults resultSet = this.dbClient.equalitySelect("version_history_dag", DbClient.SELECT_STAR, - predicates); + List> edges; - if (resultSet.isEmpty()) { + try { + edges = this.versionSuccessorFactory.retrieveFromDatabaseByItemId(itemId); + } catch (GroundException e) { + // do nothing, this just means no version have been added yet. return new VersionHistoryDag(itemId, new ArrayList<>()); } - - List> edges = new ArrayList<>(); - do { - edges.add(this.versionSuccessorFactory.retrieveFromDatabase(resultSet - .getLong("version_successor_id"))); - } while (resultSet.next()); - return new VersionHistoryDag(itemId, edges); } @@ -93,12 +82,12 @@ public void addEdge(VersionHistoryDag dag, long parentId, long childId, long ite throws GroundException { VersionSuccessor successor = this.versionSuccessorFactory.create(parentId, childId); - List insertions = new ArrayList<>(); - insertions.add(new DbDataContainer("item_id", GroundType.LONG, itemId)); - insertions.add(new DbDataContainer("version_successor_id", GroundType.LONG, successor.getId())); - - this.dbClient.insert("version_history_dag", insertions); + // Adding to the entry with id = successor.getId() + List newValue = new ArrayList<>(), predicate = new ArrayList<>(); + newValue.add(new DbDataContainer("item_id", GroundType.LONG, itemId)); + predicate.add(new DbDataContainer("id", GroundType.LONG, successor.getId())); + this.dbClient.update(newValue, predicate, "version_successor"); dag.addEdge(parentId, childId, successor.getId()); } @@ -147,14 +136,18 @@ public void truncate(VersionHistoryDag dag, int numLevels, Class tableNamePrefix = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, tableNamePrefix); if (itemType.equals(Structure.class)) { - predicates.add(new DbDataContainer("structure_version_id", GroundType.LONG, id)); - this.dbClient.delete(predicates, "structure_version_attribute"); + predicates.add(new DbDataContainer("id", GroundType.LONG, id)); + List columns = new ArrayList<>(); + columns.add("key_type_map"); + this.dbClient.deleteColumn(predicates, "structure_version", columns); predicates.clear(); } if (itemType.getName().toLowerCase().contains("graph")) { - predicates.add(new DbDataContainer(tableNamePrefix + "_version_id", GroundType.LONG, id)); - this.dbClient.delete(predicates, tableNamePrefix + "_version_edge"); + predicates.add(new DbDataContainer("id", GroundType.LONG, id)); + List columns = new ArrayList<>(); + columns.add("edge_version_set"); + this.dbClient.deleteColumn(predicates, "graph_version", columns); predicates.clear(); } diff --git a/app/dao/versions/cassandra/CassandraVersionSuccessorFactory.java b/app/dao/versions/cassandra/CassandraVersionSuccessorFactory.java index 08d71001..dda0c5ec 100644 --- a/app/dao/versions/cassandra/CassandraVersionSuccessorFactory.java +++ b/app/dao/versions/cassandra/CassandraVersionSuccessorFactory.java @@ -20,14 +20,13 @@ import db.DbClient; import db.DbDataContainer; import exceptions.GroundException; +import java.util.ArrayList; +import java.util.List; import models.versions.GroundType; import models.versions.Version; import models.versions.VersionSuccessor; import util.IdGenerator; -import java.util.ArrayList; -import java.util.List; - public class CassandraVersionSuccessorFactory implements VersionSuccessorFactory { private final CassandraClient dbClient; private final IdGenerator idGenerator; @@ -66,6 +65,29 @@ public VersionSuccessor create(long fromId, long toId) return new VersionSuccessor<>(dbId, toId, fromId); } + public List> retrieveFromDatabaseByItemId(long itemId) + throws GroundException { + CassandraResults resultSet; + + List> versionSuccessors = new ArrayList<>(); + List predicate = new ArrayList<>(); + predicate.add(new DbDataContainer("item_id", GroundType.LONG, itemId)); + resultSet = this.dbClient.equalitySelect("version_successor", DbClient.SELECT_STAR, predicate); + + if (resultSet.isEmpty()) { + throw new GroundException("No VersionSuccessor found with itemId " + itemId + "."); + } + + do { + long id = resultSet.getLong("id"); + long fromId = resultSet.getLong("from_version_id"); + long toId = resultSet.getLong("to_version_id"); + versionSuccessors.add(new VersionSuccessor<>(id, fromId, toId)); + } while (resultSet.next()); + + return versionSuccessors; + } + /** * Retrieve a version successor from the database. * @@ -115,12 +137,6 @@ public void deleteFromDestination(long toId, long itemId) throws GroundException do { long dbId = resultSet.getLong("id"); - predicates.clear(); - predicates.add(new DbDataContainer("item_id", GroundType.LONG, itemId)); - predicates.add(new DbDataContainer("version_successor_id", GroundType.LONG, dbId)); - - this.dbClient.delete(predicates, "version_history_dag"); - predicates.clear(); predicates.add(new DbDataContainer("id", GroundType.LONG, dbId)); diff --git a/app/db/CassandraClient.java b/app/db/CassandraClient.java index caab8fd4..14f5d1f3 100644 --- a/app/db/CassandraClient.java +++ b/app/db/CassandraClient.java @@ -20,15 +20,15 @@ import com.datastax.driver.core.PreparedStatement; import com.datastax.driver.core.ResultSet; import com.datastax.driver.core.Session; - +import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Set; import java.util.stream.Collectors; - import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -81,12 +81,52 @@ public void insert(String table, List insertValues) { String insert = "insert into " + table + "(" + fields + ") values (" + values + ");"; + // Ensure the following tables have unique entries + if (table.equals("edge") || table.equals("node") || table.equals("graph") || table.equals("structure")) { + insert = insert.substring(0, insert.length() - 1) + "IF NOT EXISTS;"; + } + BoundStatement statement = bind(insert, insertValues); LOGGER.info("Executing update: " + statement.preparedStatement().getQueryString() + "."); this.session.execute(statement); } + /** + * + * @param table the table to update + * @param setName the name of the set (column) being appended to + * @param values a set containing all values to be added. Set type must match with column type + * @param predicates values specifying which row will be updated + */ + public void addToSet(String table, String setName, + Set values, List predicates) { + this.modifySet(table, setName, values, predicates, true); + } + + public void addToMap(String table, String mapName, Map keyValues, + List predicates) { + String predicatesString = + predicates + .stream() + .map(predicate -> predicate.getField() + " = ?") + .collect(Collectors.joining(" and ")); + String whereString = " where " + predicatesString + ";"; + String query = "UPDATE " + table + " SET " + mapName + " = " + mapName + " + " + " ? " + whereString; + + BoundStatement statement = this.prepareStatement(query); + + List values = new ArrayList<>(); + values.add(keyValues); + for (DbDataContainer dataContainer : predicates) { + values.add(dataContainer.getValue()); + } + statement.bind(values.toArray(new Object[values.size()])); + + LOGGER.info("Executing update: " + statement.preparedStatement().getQueryString() + "."); + this.session.execute(statement); + } + /** * Retrieve rows based on a set of predicates. * @@ -109,6 +149,7 @@ public CassandraResults equalitySelect(String table, select += " where " + predicatesString; } + // This might not be very efficient https://www.datastax.com/dev/blog/allow-filtering-explained-2 select += " ALLOW FILTERING;"; BoundStatement statement = bind(select, predicatesAndValues); @@ -119,6 +160,28 @@ public CassandraResults equalitySelect(String table, return new CassandraResults(resultSet); } + /** + * + * @param table the table to query + * @param projection the set of columns to retrieve + * @param collectionName the name of the set we will search + * @param value the value searched for in the set + */ + public CassandraResults selectWhereCollectionContains( + String table, List projection, String collectionName, DbDataContainer value) { + String query = "SELECT " + String.join(", ", projection) + " FROM " + table + " WHERE " + collectionName + + " CONTAINS ?;"; + + List predicates = new ArrayList<>(); + predicates.add(value); + BoundStatement statement = bind(query, predicates); + + LOGGER.info("Executing query: " + statement.preparedStatement().getQueryString() + "."); + ResultSet resultSet = this.session.execute(statement); + + return new CassandraResults(resultSet); + } + /** * Execute an update statement in Cassandra. * @@ -173,6 +236,41 @@ public void delete(List predicates, String table) { this.session.execute(statement); } + /** + * Deletes values from a set + * @param table the table to update + * @param setName the name of the set (column) being updated + * @param values a set containing all values to be deleted. Set type must match with column type + * @param predicates values specifying which row will be updated + */ + public void deleteFromSet(String table, String setName, + Set values, List predicates) { + this.modifySet(table, setName, values, predicates, false); + } + + /** + * Deletes a column from a table + * @param predicates the predicates used to match row(s) to delete from + * @param table the table to delete from + * @param columnNames the columns to delete + */ + public void deleteColumn(List predicates, String table, List columnNames) { + String names = columnNames.stream().collect(Collectors.joining(", ")); + + String deleteString = "delete " + names + " from " + table + " "; + + String predicateString = predicates.stream().map(predicate -> predicate.getField() + " = ? ") + .collect(Collectors.joining(" and ")); + + deleteString += "where " + predicateString; + + BoundStatement statement = bind(deleteString, predicates); + + + this.session.execute(statement); + } + + private BoundStatement bind(String statement, List... predicates) { BoundStatement boundStatement = this.prepareStatement(statement); List values = Arrays.stream(predicates).flatMap(Collection::stream) @@ -193,6 +291,44 @@ public void close() { this.cluster.close(); } + /** + * Adds or subtracts the specified elements from a set + * @param table the table to update + * @param setName the name of the set (column) being added to or subtracted from + * @param values a set containing all relevant values. Set type must match with column type + * @param predicates values specifying which row will be updated + * @param add true if adding false if subtracting + */ + private void modifySet(String table, String setName, + Set values, List predicates, boolean add) { + String symbol; + if (add) { + symbol = " + "; + } else { + symbol = " - "; + } + + String predicatesString = + predicates + .stream() + .map(predicate -> predicate.getField() + " = ?") + .collect(Collectors.joining(" and ")); + String whereString = " where " + predicatesString + ";"; + String query = "UPDATE " + table + " SET " + setName + " = " + setName + symbol + " ? " + whereString; + + BoundStatement statement = this.prepareStatement(query); + + List valuesToAdd = new ArrayList<>(); + valuesToAdd.add(values); + for (DbDataContainer dataContainer : predicates) { + valuesToAdd.add(dataContainer.getValue()); + } + statement.bind(valuesToAdd.toArray(new Object[valuesToAdd.size()])); + + LOGGER.info("Executing update: " + statement.preparedStatement().getQueryString() + "."); + this.session.execute(statement); + } + private BoundStatement prepareStatement(String sql) { // Use the cached statement if possible; otherwise, prepare a new statement. PreparedStatement statement = diff --git a/app/db/CassandraResults.java b/app/db/CassandraResults.java index 97290a75..3deccc89 100644 --- a/app/db/CassandraResults.java +++ b/app/db/CassandraResults.java @@ -21,6 +21,9 @@ import exceptions.GroundDbException; import models.versions.GroundType; +import java.util.Map; +import java.util.Set; + public class CassandraResults { private final ResultSet resultSet; private Row currentRow; @@ -92,6 +95,22 @@ public long getLong(String field) throws GroundDbException { } } + public Map getMap(String field, Class keyKlass, Class valueKlass) throws GroundDbException { + try { + return this.currentRow.getMap(field, keyKlass, valueKlass); + } catch (Exception e) { + throw new GroundDbException(e); + } + } + + public Set getSet(String field, Class klass) throws GroundDbException { + try { + return this.currentRow.getSet(field, klass); + } catch (Exception e) { + throw new GroundDbException(e); + } + } + /** * Move on to the next column in the result set. * diff --git a/scripts/cassandra/cassandra.cql b/scripts/cassandra/cassandra.cql index a5448811..6b1048e7 100644 --- a/scripts/cassandra/cassandra.cql +++ b/scripts/cassandra/cassandra.cql @@ -21,7 +21,8 @@ CREATE TABLE IF NOT EXISTS version ( CREATE TABLE IF NOT EXISTS version_successor ( id bigint PRIMARY KEY, from_version_id bigint, - to_version_id bigint + to_version_id bigint, + item_id bigint ); CREATE TABLE IF NOT EXISTS item ( @@ -36,31 +37,18 @@ CREATE TABLE IF NOT EXISTS item_tag ( PRIMARY KEY (item_id, key) ); -CREATE TABLE IF NOT EXISTS version_history_dag ( - item_id bigint, - version_successor_id bigint, - PRIMARY KEY(item_id, version_successor_id) -); - -- MODELS CREATE TABLE IF NOT EXISTS structure ( - item_id bigint, + item_id bigint PRIMARY KEY, source_key varchar, - name varchar, - PRIMARY KEY (item_id, source_key) + name varchar ); CREATE TABLE IF NOT EXISTS structure_version ( id bigint PRIMARY KEY, - structure_id bigint -); - -CREATE TABLE IF NOT EXISTS structure_version_attribute ( - structure_version_id bigint, - key varchar, - type varchar, - PRIMARY KEY (structure_version_id, key) + structure_id bigint, + key_type_map map ); CREATE TABLE IF NOT EXISTS rich_version ( @@ -85,26 +73,23 @@ CREATE TABLE IF NOT EXISTS rich_version_tag ( ); CREATE TABLE IF NOT EXISTS edge ( - item_id bigint, + item_id bigint PRIMARY KEY, source_key varchar, from_node_id bigint, to_node_id bigint, - name varchar, - PRIMARY KEY (item_id, source_key) + name varchar ); CREATE TABLE IF NOT EXISTS node ( - item_id bigint, + item_id bigint PRIMARY KEY, source_key varchar, - name varchar, - PRIMARY KEY (item_id, source_key) + name varchar ); CREATE TABLE IF NOT EXISTS graph ( - item_id bigint, + item_id bigint PRIMARY KEY, source_key varchar, - name varchar, - PRIMARY KEY (item_id, source_key) + name varchar ); CREATE TABLE IF NOT EXISTS node_version ( @@ -123,13 +108,8 @@ CREATE TABLE IF NOT EXISTS edge_version ( CREATE TABLE IF NOT EXISTS graph_version ( id bigint PRIMARY KEY, - graph_id bigint -); - -CREATE TABLE IF NOT EXISTS graph_version_edge ( - graph_version_id bigint, - edge_version_id bigint, - PRIMARY KEY (graph_version_id, edge_version_id) + graph_id bigint, + edge_version_set set ); -- USAGE @@ -165,14 +145,10 @@ CREATE TABLE IF NOT EXISTS lineage_graph ( CREATE TABLE IF NOT EXISTS lineage_graph_version ( id bigint PRIMARY KEY, - lineage_graph_id bigint + lineage_graph_id bigint, + lineage_edge_version_id_set set ); -CREATE TABLE IF NOT EXISTS lineage_graph_version_edge ( - lineage_graph_version_id bigint, - lineage_edge_version_id bigint, - PRIMARY KEY (lineage_graph_version_id, lineage_edge_version_id) -); -- CREATE EMPTY VERSION diff --git a/scripts/cassandra/drop_cassandra.cql b/scripts/cassandra/drop_cassandra.cql index 4d273e0d..ac89eb9b 100644 --- a/scripts/cassandra/drop_cassandra.cql +++ b/scripts/cassandra/drop_cassandra.cql @@ -12,27 +12,23 @@ * limitations under the License. */ -DROP TABLE lineage_graph_version_edge; -DROP TABLE lineage_graph_version; -DROP TABLE lineage_graph; -DROP TABLE lineage_edge_version; -DROP TABLE lineage_edge; -DROP TABLE principal; -DROP TABLE graph_version_edge; -DROP TABLE graph_version; -DROP TABLE edge_version; -DROP TABLE node_version; -DROP TABLE graph; -DROP TABLE node; -DROP TABLE edge; -DROP TABLE rich_version_tag; -DROP TABLE rich_version_external_parameter; -DROP TABLE rich_version; -DROP TABLE structure_version_attribute; -DROP TABLE structure_version; -DROP TABLE structure; -DROP TABLE version_history_dag; -DROP TABLE item_tag; -DROP TABLE item; -DROP TABLE version_successor; -DROP TABLE version; +drop table lineage_graph_version; +drop table lineage_graph; +drop table lineage_edge_version; +drop table lineage_edge; +drop table principal; +drop table graph_version; +drop table edge_version; +drop table node_version; +drop table graph; +drop table node; +drop table edge; +drop table rich_version_tag; +drop table rich_version_external_parameter; +drop table rich_version; +drop table structure_version; +drop table structure; +drop table item_tag; +drop table item; +drop table version_successor; +drop table version; diff --git a/scripts/cassandra/truncate.cql b/scripts/cassandra/truncate.cql index 4c175ce1..a1d2972d 100644 --- a/scripts/cassandra/truncate.cql +++ b/scripts/cassandra/truncate.cql @@ -11,14 +11,11 @@ -- See the License for the specific language governing permissions and -- limitations under the License. - -TRUNCATE lineage_graph_version_edge; TRUNCATE lineage_graph_version; TRUNCATE lineage_graph; TRUNCATE lineage_edge_version; TRUNCATE lineage_edge; TRUNCATE principal; -TRUNCATE graph_version_edge; TRUNCATE graph_version; TRUNCATE edge_version; TRUNCATE node_version; @@ -28,10 +25,8 @@ TRUNCATE edge; TRUNCATE rich_version_tag; TRUNCATE rich_version_external_parameter; TRUNCATE rich_version; -TRUNCATE structure_version_attribute; TRUNCATE structure_version; TRUNCATE structure; -TRUNCATE version_history_dag; TRUNCATE item_tag; TRUNCATE item; TRUNCATE version_successor;